From 652e13e7c06db318d88a93db24a8fb2c2f8d249b Mon Sep 17 00:00:00 2001 From: Loris Cro Date: Fri, 28 Jan 2022 22:50:03 +0100 Subject: [PATCH 001/137] autodoc: init work --- src/Autodoc.zig | 555 ++++++++++++++++++++++++++++++++++++++++++++ src/Compilation.zig | 8 + 2 files changed, 563 insertions(+) create mode 100644 src/Autodoc.zig diff --git a/src/Autodoc.zig b/src/Autodoc.zig new file mode 100644 index 0000000000..31290f672f --- /dev/null +++ b/src/Autodoc.zig @@ -0,0 +1,555 @@ +const std = @import("std"); +const Autodoc = @This(); +const Compilation = @import("Compilation.zig"); +const Module = @import("Module.zig"); +const Zir = @import("Zir.zig"); + +module: *Module, +doc_location: ?Compilation.EmitLoc, + +pub fn init(m: *Module, dl: ?Compilation.EmitLoc) Autodoc { + return .{ + .doc_location = dl, + .module = m, + }; +} + +pub fn generateZirData(self: Autodoc) !void { + const gpa = self.module.gpa; + std.debug.print("yay, you called me!\n", .{}); + if (self.doc_location) |loc| { + if (loc.directory) |dir| { + if (dir.path) |path| { + std.debug.print("path: {s}\n", .{path}); + } + } + std.debug.print("basename: {s}\n", .{loc.basename}); + } + + // const root_file_path = self.module.main_pkg.root_src_path; + const root_file_path = "/home/kristoff/test/test.zig"; + const zir = self.module.import_table.get(root_file_path).?.zir; + + var types = std.ArrayList(DocData.Type).init(gpa); + var decls = std.ArrayList(DocData.Decl).init(gpa); + var ast_nodes = std.ArrayList(DocData.AstNode).init(gpa); + + // var decl_map = std.AutoHashMap(Zir.Inst.Index, usize); // values are positions in the `decls` array + + try types.append(.{ + .kind = 0, + .name = "type", + }); + + var root_scope: Scope = .{ .parent = null }; + try ast_nodes.append(.{ .name = "(root)" }); + const main_type_index = try walkInstruction(zir, gpa, &root_scope, &types, &decls, &ast_nodes, Zir.main_struct_inst); + + var data = DocData{ + .files = &[1][]const u8{root_file_path}, + .types = types.items, + .decls = decls.items, + .astNodes = ast_nodes.items, + }; + + data.packages[0].main = main_type_index.type; + + const out = std.io.getStdOut().writer(); + out.print("zigAnalysis=", .{}) catch unreachable; + std.json.stringify( + data, + .{ + .whitespace = .{}, + .emit_null_optional_fields = false, + }, + out, + ) catch unreachable; + out.print(";", .{}) catch unreachable; +} + +const Scope = struct { + parent: ?*Scope, + map: std.AutoHashMapUnmanaged(u32, usize) = .{}, // index into `decls` + + /// Assumes all decls in present scope and upper scopes have already + /// been either fully resolved or at least reserved. + pub fn resolveDeclName(self: Scope, string_table_idx: u32) usize { + var cur: ?*const Scope = &self; + return while (cur) |s| : (cur = s.parent) { + break s.map.get(string_table_idx) orelse continue; + } else unreachable; + } + + pub fn insertDeclRef( + self: *Scope, + gpa: std.mem.Allocator, + decl_name_index: u32, // decl name + decls_slot_index: usize, + ) !void { + try self.map.put(gpa, decl_name_index, decls_slot_index); + } +}; + +const DocData = struct { + typeKinds: []const []const u8 = std.meta.fieldNames(std.builtin.TypeId), + rootPkg: u32 = 0, + params: struct { + zigId: []const u8 = "arst", + zigVersion: []const u8 = "arst", + target: []const u8 = "arst", + rootName: []const u8 = "arst", + builds: []const struct { target: []const u8 } = &.{ + .{ .target = "arst" }, + }, + } = .{}, + packages: [1]Package = .{.{}}, + fns: []struct {} = &.{}, + errors: []struct {} = &.{}, + calls: []struct {} = &.{}, + + // non-hardcoded stuff + astNodes: []AstNode, + files: []const []const u8, + types: []Type, + decls: []Decl, + + const Package = struct { + name: []const u8 = "root", + file: usize = 0, // index into files + main: usize = 0, // index into decls + table: struct { root: usize } = .{ + .root = 0, + }, + }; + + const Decl = struct { + name: []const u8, + kind: []const u8, // TODO: where do we find this info? + src: usize, // index into astNodes + type: usize, // index into types + value: usize, + }; + + const AstNode = struct { + file: usize = 0, // index into files + line: usize = 0, + col: usize = 0, + name: ?[]const u8 = null, + docs: ?[]const u8 = null, + fields: ?[]usize = null, // index into astNodes + }; + + const Type = struct { + kind: u32, // index into typeKinds + name: []const u8, + src: ?usize = null, // index into astNodes + privDecls: ?[]usize = null, // index into decls + pubDecls: ?[]usize = null, // index into decls + fields: ?[]WalkResult = null, // (use src->fields to find names) + }; + + const WalkResult = union(enum) { + failure: bool, + type: usize, // index in `types` + decl_ref: usize, // index in `decls` + + pub fn jsonStringify( + self: WalkResult, + _: std.json.StringifyOptions, + w: anytype, + ) !void { + switch (self) { + .failure => |v| { + try w.print( + \\{{ "failure":{} }} + , .{v}); + }, + .type, .decl_ref => |v| { + try w.print( + \\{{ "{s}":{} }} + , .{ @tagName(self), v }); + }, + + // .decl_ref => |v| { + // try w.print( + // \\{{ "{s}":"{s}" }} + // , .{ @tagName(self), v }); + // }, + } + } + }; +}; + +fn walkInstruction( + zir: Zir, + gpa: std.mem.Allocator, + parent_scope: *Scope, + types: *std.ArrayList(DocData.Type), + decls: *std.ArrayList(DocData.Decl), + ast_nodes: *std.ArrayList(DocData.AstNode), + inst_index: usize, +) error{OutOfMemory}!DocData.WalkResult { + const tags = zir.instructions.items(.tag); + const data = zir.instructions.items(.data); + + // We assume that the topmost ast_node entry corresponds to our decl + const self_ast_node_index = ast_nodes.items.len - 1; + + switch (tags[inst_index]) { + else => { + std.debug.print( + "TODO: implement `walkInstruction` for {s}\n\n", + .{@tagName(tags[inst_index])}, + ); + return DocData.WalkResult{ .failure = true }; + }, + .decl_val => { + const str_tok = data[inst_index].str_tok; + const decls_slot_index = parent_scope.resolveDeclName(str_tok.start); + return DocData.WalkResult{ .decl_ref = decls_slot_index }; + }, + .int_type => { + const int_type = data[inst_index].int_type; + const sign = if (int_type.signedness == .unsigned) "u" else "i"; + const bits = int_type.bit_count; + const name = try std.fmt.allocPrint(gpa, "{s}{}", .{ sign, bits }); + + try types.append(.{ + .kind = @enumToInt(std.builtin.TypeId.Int), + .name = name, + }); + return DocData.WalkResult{ .type = types.items.len - 1 }; + }, + .block_inline => { + const pl_node = data[inst_index].pl_node; + const body_len = zir.extra[pl_node.payload_index]; + + std.debug.print("body len: {}\n", .{body_len}); + + const result_index = inst_index + body_len - 1; + return walkInstruction(zir, gpa, parent_scope, types, decls, ast_nodes, result_index); + }, + .extended => { + const extended = data[inst_index].extended; + switch (extended.opcode) { + else => { + std.debug.print( + "TODO: implement `walkInstruction` (inside .extended case) for {s}\n\n", + .{@tagName(extended.opcode)}, + ); + return DocData.WalkResult{ .failure = true }; + }, + .struct_decl => { + var scope: Scope = .{ .parent = parent_scope }; + + const small = @bitCast(Zir.Inst.StructDecl.Small, extended.small); + var extra_index: usize = extended.operand; + + const src_node: ?i32 = if (small.has_src_node) blk: { + const src_node = @bitCast(i32, zir.extra[extra_index]); + extra_index += 1; + break :blk src_node; + } else null; + _ = src_node; + + const body_len = if (small.has_body_len) blk: { + const body_len = zir.extra[extra_index]; + extra_index += 1; + break :blk body_len; + } else 0; + + const fields_len = if (small.has_fields_len) blk: { + const fields_len = zir.extra[extra_index]; + extra_index += 1; + break :blk fields_len; + } else 0; + _ = fields_len; + + const decls_len = if (small.has_decls_len) blk: { + const decls_len = zir.extra[extra_index]; + extra_index += 1; + break :blk decls_len; + } else 0; + + var decl_indexes = std.ArrayList(usize).init(gpa); + var priv_decl_indexes = std.ArrayList(usize).init(gpa); + + const decls_first_index = decls.items.len; + // Decl name lookahead for reserving slots in `scope` (and `decls`). + // Done to make sure that all decl refs can be resolved correctly, + // even if we haven't fully analyzed the decl yet. + { + var it = zir.declIterator(@intCast(u32, inst_index)); + try decls.resize(decls_first_index + it.decls_len); + var decls_slot_index = decls_first_index; + while (it.next()) |d| : (decls_slot_index += 1) { + const decl_name_index = zir.extra[d.sub_index + 5]; + try scope.insertDeclRef(gpa, decl_name_index, decls_slot_index); + } + } + + extra_index = try walkDecls( + zir, + gpa, + &scope, + decls, + decls_first_index, + decls_len, + &decl_indexes, + &priv_decl_indexes, + types, + ast_nodes, + extra_index, + ); + + // const body = zir.extra[extra_index..][0..body_len]; + extra_index += body_len; + + var field_type_indexes = std.ArrayList(DocData.WalkResult).init(gpa); + var field_name_indexes = std.ArrayList(usize).init(gpa); + try collectFieldInfo( + zir, + gpa, + &scope, + types, + decls, + fields_len, + &field_type_indexes, + &field_name_indexes, + ast_nodes, + extra_index, + ); + + ast_nodes.items[self_ast_node_index].fields = field_name_indexes.items; + + try types.append(.{ + .kind = @enumToInt(std.builtin.TypeId.Struct), + .name = "todo_name", + .src = self_ast_node_index, + .privDecls = priv_decl_indexes.items, + .pubDecls = decl_indexes.items, + .fields = field_type_indexes.items, + }); + + return DocData.WalkResult{ .type = types.items.len - 1 }; + }, + } + }, + } +} + +fn walkDecls( + zir: Zir, + gpa: std.mem.Allocator, + scope: *Scope, + decls: *std.ArrayList(DocData.Decl), + decls_first_index: usize, + decls_len: u32, + decl_indexes: *std.ArrayList(usize), + priv_decl_indexes: *std.ArrayList(usize), + types: *std.ArrayList(DocData.Type), + ast_nodes: *std.ArrayList(DocData.AstNode), + extra_start: usize, +) error{OutOfMemory}!usize { + const bit_bags_count = std.math.divCeil(usize, decls_len, 8) catch unreachable; + var extra_index = extra_start + bit_bags_count; + var bit_bag_index: usize = extra_start; + var cur_bit_bag: u32 = undefined; + var decl_i: u32 = 0; + + while (decl_i < decls_len) : (decl_i += 1) { + const decls_slot_index = decls_first_index + decl_i; + + if (decl_i % 8 == 0) { + cur_bit_bag = zir.extra[bit_bag_index]; + bit_bag_index += 1; + } + const is_pub = @truncate(u1, cur_bit_bag) != 0; + cur_bit_bag >>= 1; + const is_exported = @truncate(u1, cur_bit_bag) != 0; + cur_bit_bag >>= 1; + // const has_align = @truncate(u1, cur_bit_bag) != 0; + cur_bit_bag >>= 1; + // const has_section_or_addrspace = @truncate(u1, cur_bit_bag) != 0; + cur_bit_bag >>= 1; + + // const sub_index = extra_index; + + // const hash_u32s = zir.extra[extra_index..][0..4]; + extra_index += 4; + // const line = zir.extra[extra_index]; + extra_index += 1; + const decl_name_index = zir.extra[extra_index]; + extra_index += 1; + const decl_index = zir.extra[extra_index]; + extra_index += 1; + const doc_comment_index = zir.extra[extra_index]; + extra_index += 1; + + // const align_inst: Zir.Inst.Ref = if (!has_align) .none else inst: { + // const inst = @intToEnum(Zir.Inst.Ref, zir.extra[extra_index]); + // extra_index += 1; + // break :inst inst; + // }; + // const section_inst: Zir.Inst.Ref = if (!has_section_or_addrspace) .none else inst: { + // const inst = @intToEnum(Zir.Inst.Ref, zir.extra[extra_index]); + // extra_index += 1; + // break :inst inst; + // }; + // const addrspace_inst: Zir.Inst.Ref = if (!has_section_or_addrspace) .none else inst: { + // const inst = @intToEnum(Zir.Inst.Ref, zir.extra[extra_index]); + // extra_index += 1; + // break :inst inst; + // }; + + // const pub_str = if (is_pub) "pub " else ""; + // const hash_bytes = @bitCast([16]u8, hash_u32s.*); + + const name: []const u8 = blk: { + if (decl_name_index == 0) { + break :blk if (is_exported) "usingnamespace" else "comptime"; + } else if (decl_name_index == 1) { + break :blk "test"; + } else { + const raw_decl_name = zir.nullTerminatedString(decl_name_index); + if (raw_decl_name.len == 0) { + break :blk zir.nullTerminatedString(decl_name_index + 1); + } else { + break :blk raw_decl_name; + } + } + }; + + const doc_comment: ?[]const u8 = if (doc_comment_index != 0) + zir.nullTerminatedString(doc_comment_index) + else + null; + + // astnode + const ast_node_index = idx: { + const idx = ast_nodes.items.len; + try ast_nodes.append(.{ + .file = 0, + .line = 0, + .col = 0, + .docs = doc_comment, + .fields = null, // walkInstruction will fill `fields` if necessary + }); + break :idx idx; + }; + + const walk_result = try walkInstruction(zir, gpa, scope, types, decls, ast_nodes, decl_index); + const type_index = walk_result.type; + + if (is_pub) { + try decl_indexes.append(decls_slot_index); + } else { + try priv_decl_indexes.append(decls_slot_index); + } + + decls.items[decls_slot_index] = .{ + .name = name, + .src = ast_node_index, + .type = 0, + .value = type_index, + .kind = "const", // find where this information can be found + }; + } + + return extra_index; +} + +fn collectFieldInfo( + zir: Zir, + gpa: std.mem.Allocator, + scope: *Scope, + types: *std.ArrayList(DocData.Type), + decls: *std.ArrayList(DocData.Decl), + fields_len: usize, + field_type_indexes: *std.ArrayList(DocData.WalkResult), + field_name_indexes: *std.ArrayList(usize), + ast_nodes: *std.ArrayList(DocData.AstNode), + ei: usize, +) !void { + if (fields_len == 0) return; + var extra_index = ei; + + const bits_per_field = 4; + const fields_per_u32 = 32 / bits_per_field; + const bit_bags_count = std.math.divCeil(usize, fields_len, fields_per_u32) catch unreachable; + var bit_bag_index: usize = extra_index; + extra_index += bit_bags_count; + + var cur_bit_bag: u32 = undefined; + var field_i: u32 = 0; + while (field_i < fields_len) : (field_i += 1) { + if (field_i % fields_per_u32 == 0) { + cur_bit_bag = zir.extra[bit_bag_index]; + bit_bag_index += 1; + } + // const has_align = @truncate(u1, cur_bit_bag) != 0; + cur_bit_bag >>= 1; + // const has_default = @truncate(u1, cur_bit_bag) != 0; + cur_bit_bag >>= 1; + // const is_comptime = @truncate(u1, cur_bit_bag) != 0; + cur_bit_bag >>= 1; + const unused = @truncate(u1, cur_bit_bag) != 0; + cur_bit_bag >>= 1; + _ = unused; + + const field_name = zir.nullTerminatedString(zir.extra[extra_index]); + extra_index += 1; + const field_type = @intToEnum(Zir.Inst.Ref, zir.extra[extra_index]); + extra_index += 1; + const doc_comment_index = zir.extra[extra_index]; + extra_index += 1; + + // type + { + switch (field_type) { + .void_type => { + try field_type_indexes.append(.{ .type = types.items.len }); + try types.append(.{ + .kind = @enumToInt(std.builtin.TypeId.Void), + .name = "void", + }); + }, + .usize_type => { + try field_type_indexes.append(.{ .type = types.items.len }); + try types.append(.{ + .kind = @enumToInt(std.builtin.TypeId.Int), + .name = "usize", + }); + }, + + else => { + const enum_value = @enumToInt(field_type); + if (enum_value < Zir.Inst.Ref.typed_value_map.len) { + std.debug.print( + "TODO: handle ref type: {s}", + .{@tagName(field_type)}, + ); + try field_type_indexes.append(DocData.WalkResult{ .failure = true }); + } else { + const zir_index = enum_value - Zir.Inst.Ref.typed_value_map.len; + const walk_result = try walkInstruction(zir, gpa, scope, types, decls, ast_nodes, zir_index); + try field_type_indexes.append(walk_result); + } + }, + } + } + + // ast node + { + try field_name_indexes.append(ast_nodes.items.len); + const doc_comment: ?[]const u8 = if (doc_comment_index != 0) + zir.nullTerminatedString(doc_comment_index) + else + null; + try ast_nodes.append(.{ + .name = field_name, + .docs = doc_comment, + }); + } + } +} diff --git a/src/Compilation.zig b/src/Compilation.zig index 659fa5e972..cadc665598 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -34,6 +34,7 @@ const ThreadPool = @import("ThreadPool.zig"); const WaitGroup = @import("WaitGroup.zig"); const libtsan = @import("libtsan.zig"); const Zir = @import("Zir.zig"); +const Autodoc = @import("Autodoc.zig"); const Color = @import("main.zig").Color; /// General-purpose allocator. Used for both temporary and long-term storage. @@ -2866,6 +2867,13 @@ pub fn performAllTheWork( } } + if (comp.emit_docs) |doc_location| { + if (comp.bin_file.options.module) |module| { + var autodoc = Autodoc.init(module, doc_location); + try autodoc.generateZirData(); + } + } + if (!use_stage1) { const outdated_and_deleted_decls_frame = tracy.namedFrame("outdated_and_deleted_decls"); defer outdated_and_deleted_decls_frame.end(); From 025337a78d1f213183050079f79065b0a6c454de Mon Sep 17 00:00:00 2001 From: Jacob G-W Date: Fri, 28 Jan 2022 17:53:40 -0500 Subject: [PATCH 002/137] autodoc: don't hardcode file name --- src/Autodoc.zig | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/src/Autodoc.zig b/src/Autodoc.zig index 31290f672f..39919f6e22 100644 --- a/src/Autodoc.zig +++ b/src/Autodoc.zig @@ -26,9 +26,16 @@ pub fn generateZirData(self: Autodoc) !void { std.debug.print("basename: {s}\n", .{loc.basename}); } - // const root_file_path = self.module.main_pkg.root_src_path; - const root_file_path = "/home/kristoff/test/test.zig"; - const zir = self.module.import_table.get(root_file_path).?.zir; + var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined; + const dir = + if (self.module.main_pkg.root_src_directory.path) |rp| + std.os.realpath(rp, &buf) catch unreachable + else + std.os.getcwd(&buf) catch unreachable; + const root_file_path = self.module.main_pkg.root_src_path; + const abs_root_path = try std.fs.path.join(gpa, &.{ dir, root_file_path }); + defer gpa.free(abs_root_path); + const zir = self.module.import_table.get(abs_root_path).?.zir; var types = std.ArrayList(DocData.Type).init(gpa); var decls = std.ArrayList(DocData.Decl).init(gpa); From 66a46888bbf8636c4ba9e59544fc3679d39a32f6 Mon Sep 17 00:00:00 2001 From: Jacob G-W Date: Fri, 28 Jan 2022 17:54:02 -0500 Subject: [PATCH 003/137] autodoc: generate WalkResults for ref types --- src/Autodoc.zig | 24 ++++++++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/src/Autodoc.zig b/src/Autodoc.zig index 39919f6e22..87a5d48d69 100644 --- a/src/Autodoc.zig +++ b/src/Autodoc.zig @@ -47,6 +47,19 @@ pub fn generateZirData(self: Autodoc) !void { .kind = 0, .name = "type", }); + // append all the types in Zir.Inst.Ref + { + // we don't count .none + var i: u32 = 1; + while (i <= @enumToInt(Zir.Inst.Ref.anyerror_void_error_union_type)) : (i += 1) { + var tmpbuf = std.ArrayList(u8).init(gpa); + try Zir.Inst.Ref.typed_value_map[i].val.format("", .{}, tmpbuf.writer()); + try types.append(.{ + .kind = 0, + .name = tmpbuf.toOwnedSlice(), + }); + } + } var root_scope: Scope = .{ .parent = null }; try ast_nodes.append(.{ .name = "(root)" }); @@ -233,8 +246,15 @@ fn walkInstruction( std.debug.print("body len: {}\n", .{body_len}); - const result_index = inst_index + body_len - 1; - return walkInstruction(zir, gpa, parent_scope, types, decls, ast_nodes, result_index); + const break_index = inst_index + body_len; + const break_operand = data[break_index].@"break".operand; + return if (Zir.refToIndex(break_operand)) |bi| + walkInstruction(zir, gpa, parent_scope, types, decls, ast_nodes, bi) + else if (@enumToInt(break_operand) <= @enumToInt(Zir.Inst.Ref.anyerror_void_error_union_type)) + // we append all the types in ref first, so we can just do this if we encounter a ref that is a type + return DocData.WalkResult{ .type = @enumToInt(break_operand) } + else + std.debug.todo("generate WalkResults for refs that are not types"); }, .extended => { const extended = data[inst_index].extended; From 2dcaed743f27a7c53f1fa742fdc42ddd77fe15f4 Mon Sep 17 00:00:00 2001 From: Loris Cro Date: Sat, 29 Jan 2022 18:45:45 +0100 Subject: [PATCH 004/137] autodocs: add support for block_inline --- src/Autodoc.zig | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/src/Autodoc.zig b/src/Autodoc.zig index 87a5d48d69..7b897f2e05 100644 --- a/src/Autodoc.zig +++ b/src/Autodoc.zig @@ -242,11 +242,15 @@ fn walkInstruction( }, .block_inline => { const pl_node = data[inst_index].pl_node; - const body_len = zir.extra[pl_node.payload_index]; + const extra = zir.extraData(Zir.Inst.Block, pl_node.payload_index); + const break_index = zir.extra[extra.end..][extra.data.body_len - 1]; - std.debug.print("body len: {}\n", .{body_len}); + std.debug.print("[instr: {}] body len: {} last instr idx: {}\n", .{ + inst_index, + extra.data.body_len, + break_index, + }); - const break_index = inst_index + body_len; const break_operand = data[break_index].@"break".operand; return if (Zir.refToIndex(break_operand)) |bi| walkInstruction(zir, gpa, parent_scope, types, decls, ast_nodes, bi) @@ -559,7 +563,15 @@ fn collectFieldInfo( try field_type_indexes.append(DocData.WalkResult{ .failure = true }); } else { const zir_index = enum_value - Zir.Inst.Ref.typed_value_map.len; - const walk_result = try walkInstruction(zir, gpa, scope, types, decls, ast_nodes, zir_index); + const walk_result = try walkInstruction( + zir, + gpa, + scope, + types, + decls, + ast_nodes, + zir_index, + ); try field_type_indexes.append(walk_result); } }, From 9ad9664ea86897891696b35cc3f45affb06944f1 Mon Sep 17 00:00:00 2001 From: Jacob G-W Date: Sat, 29 Jan 2022 13:24:51 -0500 Subject: [PATCH 005/137] autdoc: install artifacts --- src/Autodoc.zig | 38 +++++++++++++++++++++++++++++--------- 1 file changed, 29 insertions(+), 9 deletions(-) diff --git a/src/Autodoc.zig b/src/Autodoc.zig index 7b897f2e05..c4f5026db5 100644 --- a/src/Autodoc.zig +++ b/src/Autodoc.zig @@ -5,9 +5,9 @@ const Module = @import("Module.zig"); const Zir = @import("Zir.zig"); module: *Module, -doc_location: ?Compilation.EmitLoc, +doc_location: Compilation.EmitLoc, -pub fn init(m: *Module, dl: ?Compilation.EmitLoc) Autodoc { +pub fn init(m: *Module, dl: Compilation.EmitLoc) Autodoc { return .{ .doc_location = dl, .module = m, @@ -17,14 +17,12 @@ pub fn init(m: *Module, dl: ?Compilation.EmitLoc) Autodoc { pub fn generateZirData(self: Autodoc) !void { const gpa = self.module.gpa; std.debug.print("yay, you called me!\n", .{}); - if (self.doc_location) |loc| { - if (loc.directory) |dir| { - if (dir.path) |path| { - std.debug.print("path: {s}\n", .{path}); - } + if (self.doc_location.directory) |dir| { + if (dir.path) |path| { + std.debug.print("path: {s}\n", .{path}); } - std.debug.print("basename: {s}\n", .{loc.basename}); } + std.debug.print("basename: {s}\n", .{self.doc_location.basename}); var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined; const dir = @@ -74,7 +72,23 @@ pub fn generateZirData(self: Autodoc) !void { data.packages[0].main = main_type_index.type; - const out = std.io.getStdOut().writer(); + if (self.doc_location.directory) |d| + (d.handle.makeDir(self.doc_location.basename) catch |e| switch (e) { + error.PathAlreadyExists => {}, + else => unreachable, + }) + else + (self.module.zig_cache_artifact_directory.handle.makeDir(self.doc_location.basename) catch |e| switch (e) { + error.PathAlreadyExists => {}, + else => unreachable, + }); + const output_dir = if (self.doc_location.directory) |d| + (d.handle.openDir(self.doc_location.basename, .{}) catch unreachable) + else + (self.module.zig_cache_artifact_directory.handle.openDir(self.doc_location.basename, .{}) catch unreachable); + const data_js_f = output_dir.createFile("data.js", .{}) catch unreachable; + defer data_js_f.close(); + const out = data_js_f.writer(); out.print("zigAnalysis=", .{}) catch unreachable; std.json.stringify( data, @@ -85,6 +99,12 @@ pub fn generateZirData(self: Autodoc) !void { out, ) catch unreachable; out.print(";", .{}) catch unreachable; + // copy main.js, index.html + const special = try self.module.comp.zig_lib_directory.join(gpa, &.{ "std", "special", "docs", std.fs.path.sep_str }); + var special_dir = std.fs.openDirAbsolute(special, .{}) catch unreachable; + defer special_dir.close(); + special_dir.copyFile("main.js", output_dir, "main.js", .{}) catch unreachable; + special_dir.copyFile("index.html", output_dir, "index.html", .{}) catch unreachable; } const Scope = struct { From 07ed8886b54ad09631d05cc835aa98bc81cb6ab4 Mon Sep 17 00:00:00 2001 From: Loris Cro Date: Sat, 29 Jan 2022 19:34:59 +0100 Subject: [PATCH 006/137] autodocs: refactoring: moved some fn arguments inside of self --- src/Autodoc.zig | 162 ++++++++++++++++++++++-------------------------- 1 file changed, 73 insertions(+), 89 deletions(-) diff --git a/src/Autodoc.zig b/src/Autodoc.zig index c4f5026db5..90da231233 100644 --- a/src/Autodoc.zig +++ b/src/Autodoc.zig @@ -5,21 +5,28 @@ const Module = @import("Module.zig"); const Zir = @import("Zir.zig"); module: *Module, -doc_location: Compilation.EmitLoc, +doc_location: ?Compilation.EmitLoc, +arena: std.mem.Allocator, +types: std.ArrayListUnmanaged(DocData.Type) = .{}, +decls: std.ArrayListUnmanaged(DocData.Decl) = .{}, +ast_nodes: std.ArrayListUnmanaged(DocData.AstNode) = .{}, -pub fn init(m: *Module, dl: Compilation.EmitLoc) Autodoc { +var arena_allocator: std.heap.ArenaAllocator = undefined; +pub fn init(m: *Module, doc_location: ?Compilation.EmitLoc) Autodoc { + arena_allocator = std.heap.ArenaAllocator.init(m.gpa); return .{ - .doc_location = dl, .module = m, + .doc_location = doc_location, + .arena = arena_allocator.allocator(), }; } -pub fn generateZirData(self: Autodoc) !void { - const gpa = self.module.gpa; - std.debug.print("yay, you called me!\n", .{}); - if (self.doc_location.directory) |dir| { - if (dir.path) |path| { - std.debug.print("path: {s}\n", .{path}); +pub fn generateZirData(self: *Autodoc) !void { + if (self.doc_location) |loc| { + if (loc.directory) |dir| { + if (dir.path) |path| { + std.debug.print("path: {s}\n", .{path}); + } } } std.debug.print("basename: {s}\n", .{self.doc_location.basename}); @@ -31,28 +38,21 @@ pub fn generateZirData(self: Autodoc) !void { else std.os.getcwd(&buf) catch unreachable; const root_file_path = self.module.main_pkg.root_src_path; - const abs_root_path = try std.fs.path.join(gpa, &.{ dir, root_file_path }); - defer gpa.free(abs_root_path); + const abs_root_path = try std.fs.path.join(self.arena, &.{ dir, root_file_path }); + defer self.arena.free(abs_root_path); const zir = self.module.import_table.get(abs_root_path).?.zir; - var types = std.ArrayList(DocData.Type).init(gpa); - var decls = std.ArrayList(DocData.Decl).init(gpa); - var ast_nodes = std.ArrayList(DocData.AstNode).init(gpa); - // var decl_map = std.AutoHashMap(Zir.Inst.Index, usize); // values are positions in the `decls` array - try types.append(.{ - .kind = 0, - .name = "type", - }); // append all the types in Zir.Inst.Ref { - // we don't count .none + + // TODO: we don't want to add .none, but the index math has to check out var i: u32 = 1; while (i <= @enumToInt(Zir.Inst.Ref.anyerror_void_error_union_type)) : (i += 1) { - var tmpbuf = std.ArrayList(u8).init(gpa); + var tmpbuf = std.ArrayList(u8).init(self.arena); try Zir.Inst.Ref.typed_value_map[i].val.format("", .{}, tmpbuf.writer()); - try types.append(.{ + try self.types.append(self.arena, .{ .kind = 0, .name = tmpbuf.toOwnedSlice(), }); @@ -60,14 +60,14 @@ pub fn generateZirData(self: Autodoc) !void { } var root_scope: Scope = .{ .parent = null }; - try ast_nodes.append(.{ .name = "(root)" }); - const main_type_index = try walkInstruction(zir, gpa, &root_scope, &types, &decls, &ast_nodes, Zir.main_struct_inst); + try self.ast_nodes.append(self.arena, .{ .name = "(root)" }); + const main_type_index = try self.walkInstruction(zir, &root_scope, Zir.main_struct_inst); var data = DocData{ .files = &[1][]const u8{root_file_path}, - .types = types.items, - .decls = decls.items, - .astNodes = ast_nodes.items, + .types = self.types.items, + .decls = self.decls.items, + .astNodes = self.ast_nodes.items, }; data.packages[0].main = main_type_index.type; @@ -122,11 +122,11 @@ const Scope = struct { pub fn insertDeclRef( self: *Scope, - gpa: std.mem.Allocator, + arena: std.mem.Allocator, decl_name_index: u32, // decl name decls_slot_index: usize, ) !void { - try self.map.put(gpa, decl_name_index, decls_slot_index); + try self.map.put(arena, decl_name_index, decls_slot_index); } }; @@ -221,19 +221,16 @@ const DocData = struct { }; fn walkInstruction( + self: *Autodoc, zir: Zir, - gpa: std.mem.Allocator, parent_scope: *Scope, - types: *std.ArrayList(DocData.Type), - decls: *std.ArrayList(DocData.Decl), - ast_nodes: *std.ArrayList(DocData.AstNode), inst_index: usize, ) error{OutOfMemory}!DocData.WalkResult { const tags = zir.instructions.items(.tag); const data = zir.instructions.items(.data); // We assume that the topmost ast_node entry corresponds to our decl - const self_ast_node_index = ast_nodes.items.len - 1; + const self_ast_node_index = self.ast_nodes.items.len - 1; switch (tags[inst_index]) { else => { @@ -252,13 +249,13 @@ fn walkInstruction( const int_type = data[inst_index].int_type; const sign = if (int_type.signedness == .unsigned) "u" else "i"; const bits = int_type.bit_count; - const name = try std.fmt.allocPrint(gpa, "{s}{}", .{ sign, bits }); + const name = try std.fmt.allocPrint(self.arena, "{s}{}", .{ sign, bits }); - try types.append(.{ + try self.types.append(self.arena, .{ .kind = @enumToInt(std.builtin.TypeId.Int), .name = name, }); - return DocData.WalkResult{ .type = types.items.len - 1 }; + return DocData.WalkResult{ .type = self.types.items.len - 1 }; }, .block_inline => { const pl_node = data[inst_index].pl_node; @@ -273,7 +270,7 @@ fn walkInstruction( const break_operand = data[break_index].@"break".operand; return if (Zir.refToIndex(break_operand)) |bi| - walkInstruction(zir, gpa, parent_scope, types, decls, ast_nodes, bi) + self.walkInstruction(zir, parent_scope, bi) else if (@enumToInt(break_operand) <= @enumToInt(Zir.Inst.Ref.anyerror_void_error_union_type)) // we append all the types in ref first, so we can just do this if we encounter a ref that is a type return DocData.WalkResult{ .type = @enumToInt(break_operand) } @@ -322,58 +319,50 @@ fn walkInstruction( break :blk decls_len; } else 0; - var decl_indexes = std.ArrayList(usize).init(gpa); - var priv_decl_indexes = std.ArrayList(usize).init(gpa); + var decl_indexes: std.ArrayListUnmanaged(usize) = .{}; + var priv_decl_indexes: std.ArrayListUnmanaged(usize) = .{}; - const decls_first_index = decls.items.len; + const decls_first_index = self.decls.items.len; // Decl name lookahead for reserving slots in `scope` (and `decls`). // Done to make sure that all decl refs can be resolved correctly, // even if we haven't fully analyzed the decl yet. { var it = zir.declIterator(@intCast(u32, inst_index)); - try decls.resize(decls_first_index + it.decls_len); + try self.decls.resize(self.arena, decls_first_index + it.decls_len); var decls_slot_index = decls_first_index; while (it.next()) |d| : (decls_slot_index += 1) { const decl_name_index = zir.extra[d.sub_index + 5]; - try scope.insertDeclRef(gpa, decl_name_index, decls_slot_index); + try scope.insertDeclRef(self.arena, decl_name_index, decls_slot_index); } } - extra_index = try walkDecls( + extra_index = try self.walkDecls( zir, - gpa, &scope, - decls, decls_first_index, decls_len, &decl_indexes, &priv_decl_indexes, - types, - ast_nodes, extra_index, ); // const body = zir.extra[extra_index..][0..body_len]; extra_index += body_len; - var field_type_indexes = std.ArrayList(DocData.WalkResult).init(gpa); - var field_name_indexes = std.ArrayList(usize).init(gpa); - try collectFieldInfo( + var field_type_indexes: std.ArrayListUnmanaged(DocData.WalkResult) = .{}; + var field_name_indexes: std.ArrayListUnmanaged(usize) = .{}; + try self.collectFieldInfo( zir, - gpa, &scope, - types, - decls, fields_len, &field_type_indexes, &field_name_indexes, - ast_nodes, extra_index, ); - ast_nodes.items[self_ast_node_index].fields = field_name_indexes.items; + self.ast_nodes.items[self_ast_node_index].fields = field_name_indexes.items; - try types.append(.{ + try self.types.append(self.arena, .{ .kind = @enumToInt(std.builtin.TypeId.Struct), .name = "todo_name", .src = self_ast_node_index, @@ -382,7 +371,7 @@ fn walkInstruction( .fields = field_type_indexes.items, }); - return DocData.WalkResult{ .type = types.items.len - 1 }; + return DocData.WalkResult{ .type = self.types.items.len - 1 }; }, } }, @@ -390,16 +379,13 @@ fn walkInstruction( } fn walkDecls( + self: *Autodoc, zir: Zir, - gpa: std.mem.Allocator, scope: *Scope, - decls: *std.ArrayList(DocData.Decl), decls_first_index: usize, decls_len: u32, - decl_indexes: *std.ArrayList(usize), - priv_decl_indexes: *std.ArrayList(usize), - types: *std.ArrayList(DocData.Type), - ast_nodes: *std.ArrayList(DocData.AstNode), + decl_indexes: *std.ArrayListUnmanaged(usize), + priv_decl_indexes: *std.ArrayListUnmanaged(usize), extra_start: usize, ) error{OutOfMemory}!usize { const bit_bags_count = std.math.divCeil(usize, decls_len, 8) catch unreachable; @@ -478,8 +464,8 @@ fn walkDecls( // astnode const ast_node_index = idx: { - const idx = ast_nodes.items.len; - try ast_nodes.append(.{ + const idx = self.ast_nodes.items.len; + try self.ast_nodes.append(self.arena, .{ .file = 0, .line = 0, .col = 0, @@ -489,16 +475,16 @@ fn walkDecls( break :idx idx; }; - const walk_result = try walkInstruction(zir, gpa, scope, types, decls, ast_nodes, decl_index); + const walk_result = try self.walkInstruction(zir, scope, decl_index); const type_index = walk_result.type; if (is_pub) { - try decl_indexes.append(decls_slot_index); + try decl_indexes.append(self.arena, decls_slot_index); } else { - try priv_decl_indexes.append(decls_slot_index); + try priv_decl_indexes.append(self.arena, decls_slot_index); } - decls.items[decls_slot_index] = .{ + self.decls.items[decls_slot_index] = .{ .name = name, .src = ast_node_index, .type = 0, @@ -511,15 +497,12 @@ fn walkDecls( } fn collectFieldInfo( + self: *Autodoc, zir: Zir, - gpa: std.mem.Allocator, scope: *Scope, - types: *std.ArrayList(DocData.Type), - decls: *std.ArrayList(DocData.Decl), fields_len: usize, - field_type_indexes: *std.ArrayList(DocData.WalkResult), - field_name_indexes: *std.ArrayList(usize), - ast_nodes: *std.ArrayList(DocData.AstNode), + field_type_indexes: *std.ArrayListUnmanaged(DocData.WalkResult), + field_name_indexes: *std.ArrayListUnmanaged(usize), ei: usize, ) !void { if (fields_len == 0) return; @@ -559,15 +542,17 @@ fn collectFieldInfo( { switch (field_type) { .void_type => { - try field_type_indexes.append(.{ .type = types.items.len }); - try types.append(.{ + try field_type_indexes.append(self.arena, .{ + .type = self.types.items.len, + }); + try self.types.append(self.arena, .{ .kind = @enumToInt(std.builtin.TypeId.Void), .name = "void", }); }, .usize_type => { - try field_type_indexes.append(.{ .type = types.items.len }); - try types.append(.{ + try field_type_indexes.append(self.arena, .{ .type = self.types.items.len }); + try self.types.append(self.arena, .{ .kind = @enumToInt(std.builtin.TypeId.Int), .name = "usize", }); @@ -580,19 +565,18 @@ fn collectFieldInfo( "TODO: handle ref type: {s}", .{@tagName(field_type)}, ); - try field_type_indexes.append(DocData.WalkResult{ .failure = true }); + try field_type_indexes.append( + self.arena, + DocData.WalkResult{ .failure = true }, + ); } else { const zir_index = enum_value - Zir.Inst.Ref.typed_value_map.len; - const walk_result = try walkInstruction( + const walk_result = try self.walkInstruction( zir, - gpa, scope, - types, - decls, - ast_nodes, zir_index, ); - try field_type_indexes.append(walk_result); + try field_type_indexes.append(self.arena, walk_result); } }, } @@ -600,12 +584,12 @@ fn collectFieldInfo( // ast node { - try field_name_indexes.append(ast_nodes.items.len); + try field_name_indexes.append(self.arena, self.ast_nodes.items.len); const doc_comment: ?[]const u8 = if (doc_comment_index != 0) zir.nullTerminatedString(doc_comment_index) else null; - try ast_nodes.append(.{ + try self.ast_nodes.append(self.arena, .{ .name = field_name, .docs = doc_comment, }); From 75d39a97a29a4dee905a4c2b1f06444312be3a77 Mon Sep 17 00:00:00 2001 From: Loris Cro Date: Sat, 29 Jan 2022 19:52:58 +0100 Subject: [PATCH 007/137] autodocs: fix merge conflict --- src/Autodoc.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Autodoc.zig b/src/Autodoc.zig index 90da231233..bd9398a82e 100644 --- a/src/Autodoc.zig +++ b/src/Autodoc.zig @@ -100,7 +100,7 @@ pub fn generateZirData(self: *Autodoc) !void { ) catch unreachable; out.print(";", .{}) catch unreachable; // copy main.js, index.html - const special = try self.module.comp.zig_lib_directory.join(gpa, &.{ "std", "special", "docs", std.fs.path.sep_str }); + const special = try self.module.comp.zig_lib_directory.join(self.arena, &.{ "std", "special", "docs", std.fs.path.sep_str }); var special_dir = std.fs.openDirAbsolute(special, .{}) catch unreachable; defer special_dir.close(); special_dir.copyFile("main.js", output_dir, "main.js", .{}) catch unreachable; From 38281c8ed421b8febadb2d4e05291fcf4a871ccc Mon Sep 17 00:00:00 2001 From: Loris Cro Date: Sat, 29 Jan 2022 20:13:10 +0100 Subject: [PATCH 008/137] autodoc: add declval support to docs js --- lib/docs/index.html | 29 ++- lib/docs/main.js | 442 ++++++++++++++++++++------------------------ 2 files changed, 214 insertions(+), 257 deletions(-) diff --git a/lib/docs/index.html b/lib/docs/index.html index 61e3bb4ed2..45e4a6fe95 100644 --- a/lib/docs/index.html +++ b/lib/docs/index.html @@ -43,8 +43,6 @@ /* layout */ .canvas { - display: flex; - flex-direction: column; width: 100vw; height: 100vh; overflow: hidden; @@ -55,21 +53,12 @@ background-color: var(--bg-color); } - .banner { - background-color: darkred; - text-align: center; - color: white; - padding: 15px 5px; - } - - .banner a { - color: bisque; - text-decoration: underline; - } - .flex-main { display: flex; - overflow-y: hidden; + width: 100%; + height: 100%; + justify-content: center; + z-index: 100; } @@ -526,7 +515,6 @@ -
@@ -541,8 +529,14 @@
+
diff --git a/lib/docs/main.js b/lib/docs/main.js index 7dcf8a1757..f0471620f2 100644 --- a/lib/docs/main.js +++ b/lib/docs/main.js @@ -176,6 +176,8 @@ var zigAnalysis; var domListPkgs = document.getElementById("listPkgs"); var domSectTypes = document.getElementById("sectTypes"); var domListTypes = document.getElementById("listTypes"); + var domSectTests = document.getElementById("sectTests"); + var domListTests = document.getElementById("listTests"); var domSectNamespaces = document.getElementById("sectNamespaces"); var domListNamespaces = document.getElementById("listNamespaces"); var domSectErrSets = document.getElementById("sectErrSets"); @@ -349,6 +351,7 @@ var zigAnalysis; if ("declRef" in value) { value = zigAnalysis.decls[value.declRef].value; + continue; } return value; @@ -439,6 +442,7 @@ var zigAnalysis; domSectMainPkg.classList.add("hidden"); domSectPkgs.classList.add("hidden"); domSectTypes.classList.add("hidden"); + domSectTests.classList.add("hidden"); domSectNamespaces.classList.add("hidden"); domSectErrSets.classList.add("hidden"); domSectFns.classList.add("hidden"); @@ -845,10 +849,10 @@ var zigAnalysis; if ("call" in typeValue) { var result = ""; var call = zigAnalysis.calls[typeValue.call]; - var functionName = typeValueName(call.func); + var functionName = typeValueName(call.func, wantHtml, wantLink, fnDecl, linkFnNameDecl); result += functionName + "("; for (var j = 0; j < call.args.length; j += 1) { - result += typeValueName(call.args[j]); + result += typeValueName(call.args[j], wantHtml, wantLink, fnDecl, linkFnNameDecl); if (j != call.args.length -1) result += ","; } @@ -878,6 +882,22 @@ var zigAnalysis; return result; } + if ("declRef" in typeValue) { + return zigAnalysis.decls[typeValue.declRef].name; + } + + if ("string" in typeValue) { + return typeValue.string + " (string)"; + } + + if ("anytype" in typeValue) { + return "anytype"; + } + + if ("this" in typeValue) { + return "this"; + } + console.assert("type" in typeValue) var typeIndex = typeValue.type; var typeObj = zigAnalysis.types[typeIndex]; @@ -1133,7 +1153,7 @@ var zigAnalysis; if (typeObj.params) { var fields = null; var isVarArgs = false; - var fnNode = zigAnalysis.astNodes[fnDecl.src]; + var fnNode = zigAnalysis.astNodes[typeObj.src]; fields = fnNode.fields; isVarArgs = fnNode.varArgs; @@ -1411,12 +1431,17 @@ var zigAnalysis; function categorizeDecls(decls, typesList, namespacesList, errSetsList, - fnsList, varsList, valsList) { + fnsList, varsList, valsList, testsList) { for (var i = 0; i < decls.length; i += 1) { var decl = zigAnalysis.decls[decls[i]]; var declValue = resolveValue(decl.value); + if (decl.isTest) { + testsList.push(decl); + continue; + } + if (decl.kind === 'var') { varsList.push(decl); continue; @@ -1427,11 +1452,15 @@ var zigAnalysis; let c = zigAnalysis.calls[declValue.call]; console.assert("comptimeExpr" in c.ret); let fDecl = resolveValue(c.func); - console.assert("type" in fDecl); - let fType = zigAnalysis.types[fDecl.type]; - console.assert("type" in fType.ret); - if (fType.ret.type === typeTypeId) { - typesList.push(decl); + if ("type" in fDecl) { + console.assert("type" in fDecl); + let fType = zigAnalysis.types[fDecl.type]; + console.assert("type" in fType.ret); + if (fType.ret.type === typeTypeId) { + typesList.push(decl); + } else { + valsList.push(decl); + } } else { valsList.push(decl); } @@ -1468,13 +1497,14 @@ var zigAnalysis; var fnsList = []; var varsList = []; var valsList = []; + var testsList = []; categorizeDecls(container.pubDecls, typesList, namespacesList, errSetsList, - fnsList, varsList, valsList); + fnsList, varsList, valsList, testsList); if (curNav.showPrivDecls) categorizeDecls(container.privDecls, typesList, namespacesList, errSetsList, - fnsList, varsList, valsList); + fnsList, varsList, valsList, testsList); typesList.sort(byNameProperty); @@ -1483,6 +1513,7 @@ var zigAnalysis; fnsList.sort(byNameProperty); varsList.sort(byNameProperty); valsList.sort(byNameProperty); + testsList.sort(byNameProperty); if (container.src != null) { var docs = zigAnalysis.astNodes[container.src].docs; @@ -1638,6 +1669,33 @@ var zigAnalysis; } domSectValues.classList.remove("hidden"); } + + if (testsList.length !== 0) { + resizeDomList(domListTests, testsList.length, + ''); + for (var i = 0; i < testsList.length; i += 1) { + var decl = testsList[i]; + var trDom = domListTests.children[i]; + + var tdName = trDom.children[0]; + var tdNameA = tdName.children[0]; + var tdType = trDom.children[1]; + var tdDesc = trDom.children[2]; + + tdNameA.setAttribute('href', navLinkDecl(decl.name)); + tdNameA.textContent = decl.name; + + tdType.innerHTML = typeValueName(typeOfDecl(decl), true, true); + + var docs = zigAnalysis.astNodes[decl.src].docs; + if (docs != null) { + tdDesc.innerHTML = shortDescMarkdown(docs); + } else { + tdDesc.textContent = ""; + } + } + domSectTests.classList.remove("hidden"); + } } function operatorCompare(a, b) { diff --git a/src/Autodoc.zig b/src/Autodoc.zig index 59a7c1bbd5..913851154c 100644 --- a/src/Autodoc.zig +++ b/src/Autodoc.zig @@ -354,6 +354,7 @@ const DocData = struct { const Decl = struct { name: []const u8, kind: []const u8, + isTest: bool, src: usize, // index into astNodes // typeRef: TypeRef, value: WalkResult, @@ -621,7 +622,6 @@ const DocData = struct { .@"undefined" => |v| try std.json.stringify(v, options, w), .@"null" => |v| try std.json.stringify(v, options, w), .typeOf, .sizeOf => |v| try std.json.stringify(v, options, w), - .compileError => |v| try std.json.stringify(v, options, w), .fieldRef => |v| try std.json.stringify( struct { fieldRef: FieldRef }{ .fieldRef = v }, options, @@ -645,6 +645,11 @@ const DocData = struct { options, w, ), + .compileError => |v| try std.json.stringify( + struct { compileError: []const u8 }{ .compileError = v }, + options, + w, + ), .string => |v| try std.json.stringify( struct { string: []const u8 }{ .string = v }, options, @@ -1678,7 +1683,7 @@ fn walkDecls( extra_index += 1; const decl_name_index = file.zir.extra[extra_index]; extra_index += 1; - const decl_index = file.zir.extra[extra_index]; + const value_index = file.zir.extra[extra_index]; extra_index += 1; const doc_comment_index = file.zir.extra[extra_index]; extra_index += 1; @@ -1722,7 +1727,7 @@ fn walkDecls( const idx = self.ast_nodes.items.len; const file_source = file.getSource(self.module.gpa) catch unreachable; // TODO fix this const source_of_decltest_function = srcloc: { - const func_index = getBlockInlineBreak(file.zir, decl_index); + const func_index = getBlockInlineBreak(file.zir, value_index); // a decltest is always a function const tag = file.zir.instructions.items(.tag)[Zir.refToIndex(func_index).?]; std.debug.assert(tag == .extended); @@ -1785,6 +1790,7 @@ fn walkDecls( self.decls.items[decls_slot_index] = .{ ._analyzed = true, .name = "test", + .isTest = true, .src = ast_node_index, .value = .{ .type = 0 }, .kind = "const", @@ -1822,7 +1828,7 @@ fn walkDecls( const walk_result = if (is_test) // TODO: decide if tests should show up at all DocData.WalkResult{ .void = {} } else - try self.walkInstruction(file, scope, decl_index); + try self.walkInstruction(file, scope, value_index); if (is_pub) { try decl_indexes.append(self.arena, decls_slot_index); @@ -1848,6 +1854,7 @@ fn walkDecls( self.decls.items[decls_slot_index] = .{ ._analyzed = true, .name = name, + .isTest = is_test, .src = ast_node_index, // .typeRef = decl_type_ref, .value = walk_result, @@ -1859,7 +1866,7 @@ fn walkDecls( for (paths.items) |resume_info| { try self.tryResolveRefPath( resume_info.file, - decl_index, + value_index, resume_info.ref_path, ); } @@ -2283,7 +2290,7 @@ fn analyzeFunction( .ret = ret_type_ref, }, }; - return DocData.WalkResult{ .type = self.types.items.len - 1 }; + return DocData.WalkResult{ .type = type_slot_index }; } fn collectUnionFieldInfo( @@ -2553,10 +2560,12 @@ fn typeOfWalkResult(self: *Autodoc, wr: DocData.WalkResult) !DocData.WalkResult } fn getBlockInlineBreak(zir: Zir, inst_index: usize) Zir.Inst.Ref { + const tags = zir.instructions.items(.tag); const data = zir.instructions.items(.data); const pl_node = data[inst_index].pl_node; const extra = zir.extraData(Zir.Inst.Block, pl_node.payload_index); const break_index = zir.extra[extra.end..][extra.data.body_len - 1]; + std.debug.assert(tags[break_index] == .break_inline); return data[break_index].@"break".operand; } From 64feb222b52ae135c23fec55a2431fd733a6f1e8 Mon Sep 17 00:00:00 2001 From: Loris Cro Date: Wed, 30 Mar 2022 17:10:37 +0200 Subject: [PATCH 044/137] autodoc: make links respect internal docs mode --- lib/docs/index.html | 2 +- lib/docs/main.js | 13 +++++++++---- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/lib/docs/index.html b/lib/docs/index.html index d5b9cafcdd..a786e2879d 100644 --- a/lib/docs/index.html +++ b/lib/docs/index.html @@ -546,7 +546,7 @@

- Show Private Decls + Internal Documentation Mode
diff --git a/lib/docs/main.js b/lib/docs/main.js index f0471620f2..93a8b366fa 100644 --- a/lib/docs/main.js +++ b/lib/docs/main.js @@ -781,14 +781,19 @@ var zigAnalysis; } function navLink(pkgNames, declNames, callName) { + let base = '#'; + if (curNav.showPrivDecls) { + base += "*"; + } + if (pkgNames.length === 0 && declNames.length === 0) { - return '#'; + return base; } else if (declNames.length === 0 && callName == null) { - return '#' + pkgNames.join('.'); + return base + pkgNames.join('.'); } else if (callName == null) { - return '#' + pkgNames.join('.') + ';' + declNames.join('.'); + return base + pkgNames.join('.') + ';' + declNames.join('.'); } else { - return '#' + pkgNames.join('.') + ';' + declNames.join('.') + ';' + callName; + return base + pkgNames.join('.') + ';' + declNames.join('.') + ';' + callName; } } From 72e5b4fb747908d4cf4e5039c671ec729e5b7716 Mon Sep 17 00:00:00 2001 From: Loris Cro Date: Wed, 30 Mar 2022 19:06:02 +0200 Subject: [PATCH 045/137] autodoc: improve type checking in main.js --- lib/docs/main.js | 303 ++++++++++++++++++++++++++++------------------- 1 file changed, 181 insertions(+), 122 deletions(-) diff --git a/lib/docs/main.js b/lib/docs/main.js index 93a8b366fa..1966beb7a9 100644 --- a/lib/docs/main.js +++ b/lib/docs/main.js @@ -57,15 +57,19 @@ /** * @typedef { - { kind: number } & ( - | { name: string } // Type, Void, Bool, NoReturn, Int, Float, ComptimeExpr, ComptimeFloat, ComptimeInt, Undefined, Null, ErrorUnion, BoundFn, Opaque, Frame, AnyFrame, Vector, EnumLiteral - | { name: string; child: TypeRef } // Optional - | { len: WalkResult; child: TypeRef } // Array - | { name: string; fields: { name: string; docs: string }[] } // ErrorSet - | { size: "One" | "Many" | "Slice" | "C"; child: TypeRef } // Pointer - | { name: string; src: number; privDecls: number[]; pubDecls: number[]; fields: WalkResult[] } // Struct, Enum, Union - | { name: string; src: number; ret: WalkResult; params: WalkResult[] } // Fn - ) + | { kind: number, name: string; src: number; privDecls: number[]; pubDecls: number[]; fields: WalkResult[] } // Struct, Enum, Union + } ContainerType +*/ + +/** + * @typedef { + | { kind: number, name: string } // Type, Void, Bool, NoReturn, Int, Float, ComptimeExpr, ComptimeFloat, ComptimeInt, Undefined, Null, ErrorUnion, BoundFn, Opaque, Frame, AnyFrame, Vector, EnumLiteral + | { kind: number, name: string; child: TypeRef } // Optional + | { kind: number, len: WalkResult; child: TypeRef } // Array + | { kind: number, name: string; fields: { name: string; docs: string }[] } // ErrorSet + | { kind: number, size: "One" | "Many" | "Slice" | "C"; child: TypeRef } // Pointer + | ContainerType + | { kind: number, name: string; src: number; ret: WalkResult; params: WalkResult[] } // Fn } Type */ @@ -156,7 +160,7 @@ errors: {}; astNodes: AstNode[]; calls: Call[]; - files: Record; + files: Record; types: Type[]; decls: Decl[]; comptimeExprs: ComptimeExpr[]; @@ -168,53 +172,57 @@ var zigAnalysis; (function() { - var domStatus = document.getElementById("status"); - var domSectNav = document.getElementById("sectNav"); - var domListNav = document.getElementById("listNav"); - var domSectMainPkg = document.getElementById("sectMainPkg"); - var domSectPkgs = document.getElementById("sectPkgs"); - var domListPkgs = document.getElementById("listPkgs"); - var domSectTypes = document.getElementById("sectTypes"); - var domListTypes = document.getElementById("listTypes"); - var domSectTests = document.getElementById("sectTests"); - var domListTests = document.getElementById("listTests"); - var domSectNamespaces = document.getElementById("sectNamespaces"); - var domListNamespaces = document.getElementById("listNamespaces"); - var domSectErrSets = document.getElementById("sectErrSets"); - var domListErrSets = document.getElementById("listErrSets"); - var domSectFns = document.getElementById("sectFns"); - var domListFns = document.getElementById("listFns"); - var domSectFields = document.getElementById("sectFields"); - var domListFields = document.getElementById("listFields"); - var domSectGlobalVars = document.getElementById("sectGlobalVars"); - var domListGlobalVars = document.getElementById("listGlobalVars"); - var domSectValues = document.getElementById("sectValues"); - var domListValues = document.getElementById("listValues"); - var domFnProto = document.getElementById("fnProto"); - var domFnProtoCode = document.getElementById("fnProtoCode"); - var domSectParams = document.getElementById("sectParams"); - var domListParams = document.getElementById("listParams"); - var domTldDocs = document.getElementById("tldDocs"); - var domSectFnErrors = document.getElementById("sectFnErrors"); - var domListFnErrors = document.getElementById("listFnErrors"); - var domTableFnErrors = document.getElementById("tableFnErrors"); - var domFnErrorsAnyError = document.getElementById("fnErrorsAnyError"); - var domFnExamples = document.getElementById("fnExamples"); - var domListFnExamples = document.getElementById("listFnExamples"); - var domFnNoExamples = document.getElementById("fnNoExamples"); - var domDeclNoRef = document.getElementById("declNoRef"); - var domSearch = document.getElementById("search"); - var domSectSearchResults = document.getElementById("sectSearchResults"); - var domListSearchResults = document.getElementById("listSearchResults"); - var domSectSearchNoResults = document.getElementById("sectSearchNoResults"); - var domSectInfo = document.getElementById("sectInfo"); - var domTdTarget = document.getElementById("tdTarget"); - var domPrivDeclsBox = document.getElementById("privDeclsBox"); - var domTdZigVer = document.getElementById("tdZigVer"); - var domHdrName = document.getElementById("hdrName"); - var domHelpModal = document.getElementById("helpDialog"); + var domStatus = /** @type HTMLElement */(document.getElementById("status")); + var domSectNav = /** @type HTMLElement */(document.getElementById("sectNav")); + var domListNav = /** @type HTMLElement */(document.getElementById("listNav")); + var domSectMainPkg = /** @type HTMLElement */(document.getElementById("sectMainPkg")); + var domSectPkgs = /** @type HTMLElement */(document.getElementById("sectPkgs")); + var domListPkgs = /** @type HTMLElement */(document.getElementById("listPkgs")); + var domSectTypes = /** @type HTMLElement */(document.getElementById("sectTypes")); + var domListTypes = /** @type HTMLElement */(document.getElementById("listTypes")); + var domSectTests = /** @type HTMLElement */(document.getElementById("sectTests")); + var domListTests = /** @type HTMLElement */(document.getElementById("listTests")); + var domSectNamespaces = /** @type HTMLElement */(document.getElementById("sectNamespaces")); + var domListNamespaces = /** @type HTMLElement */(document.getElementById("listNamespaces")); + var domSectErrSets = /** @type HTMLElement */(document.getElementById("sectErrSets")); + var domListErrSets = /** @type HTMLElement */(document.getElementById("listErrSets")); + var domSectFns = /** @type HTMLElement */(document.getElementById("sectFns")); + var domListFns = /** @type HTMLElement */(document.getElementById("listFns")); + var domSectFields = /** @type HTMLElement */(document.getElementById("sectFields")); + var domListFields = /** @type HTMLElement */(document.getElementById("listFields")); + var domSectGlobalVars = /** @type HTMLElement */(document.getElementById("sectGlobalVars")); + var domListGlobalVars = /** @type HTMLElement */(document.getElementById("listGlobalVars")); + var domSectValues = /** @type HTMLElement */(document.getElementById("sectValues")); + var domListValues = /** @type HTMLElement */(document.getElementById("listValues")); + var domFnProto = /** @type HTMLElement */(document.getElementById("fnProto")); + var domFnProtoCode = /** @type HTMLElement */(document.getElementById("fnProtoCode")); + var domSectParams = /** @type HTMLElement */(document.getElementById("sectParams")); + var domListParams = /** @type HTMLElement */(document.getElementById("listParams")); + var domTldDocs = /** @type HTMLElement */(document.getElementById("tldDocs")); + var domSectFnErrors = /** @type HTMLElement */(document.getElementById("sectFnErrors")); + var domListFnErrors = /** @type HTMLElement */(document.getElementById("listFnErrors")); + var domTableFnErrors =/** @type HTMLElement */(document.getElementById("tableFnErrors")); + var domFnErrorsAnyError = /** @type HTMLElement */(document.getElementById("fnErrorsAnyError")); + var domFnExamples = /** @type HTMLElement */(document.getElementById("fnExamples")); + var domListFnExamples = /** @type HTMLElement */(document.getElementById("listFnExamples")); + var domFnNoExamples = /** @type HTMLElement */(document.getElementById("fnNoExamples")); + var domDeclNoRef = /** @type HTMLElement */(document.getElementById("declNoRef")); + var domSearch = /** @type HTMLInputElement */(document.getElementById("search")); + var domSectSearchResults = /** @type HTMLElement */(document.getElementById("sectSearchResults")); + var domListSearchResults = /** @type HTMLElement */(document.getElementById("listSearchResults")); + var domSectSearchNoResults = /** @type HTMLElement */(document.getElementById("sectSearchNoResults")); + var domSectInfo = /** @type HTMLElement */(document.getElementById("sectInfo")); + var domTdTarget = /** @type HTMLElement */(document.getElementById("tdTarget")); + var domPrivDeclsBox = /** @type HTMLElement */(document.getElementById("privDeclsBox")); + var domTdZigVer = /** @type HTMLElement */(document.getElementById("tdZigVer")); + var domHdrName = /** @type HTMLElement */(document.getElementById("hdrName")); + var domHelpModal = /** @type HTMLElement */(document.getElementById("helpDialog")); + + /** @type number | null */ var searchTimer = null; + + /** @type Object */ var escapeHtmlReplacements = { "&": "&", '"': """, "<": "<", ">": ">" }; var typeKinds = indexTypeKinds(); @@ -298,12 +306,6 @@ var zigAnalysis; return isType(x) && typeKindIsContainer(x.kind) ; } - function declContainsType(x){ - console.assert("value" in x); - - - } - function typeShorthandName(type) { var name = type.name; if (type.kind === typeKinds.Struct) { @@ -1434,6 +1436,10 @@ var zigAnalysis; } + /** + * @param {number[]} decls + * @param {Decl[]} typesList, namespacesList, errSetsList, fnsList, varsList, valsList, testsList + */ function categorizeDecls(decls, typesList, namespacesList, errSetsList, fnsList, varsList, valsList, testsList) { @@ -1495,13 +1501,23 @@ var zigAnalysis; } } + /** + * @param {ContainerType} container + */ function renderContainer(container) { + /** @type {Decl[]} */ var typesList = []; + /** @type {Decl[]} */ var namespacesList = []; + /** @type {Decl[]} */ var errSetsList = []; + /** @type {Decl[]} */ var fnsList = []; + /** @type {Decl[]} */ var varsList = []; + /** @type {Decl[]} */ var valsList = []; + /** @type {Decl[]} */ var testsList = []; categorizeDecls(container.pubDecls, @@ -1911,20 +1927,32 @@ var zigAnalysis; return canonTypeDecls[index]; } + /** @param {string} text */ function escapeHtml(text) { return text.replace(/[&"<>]/g, function (m) { return escapeHtmlReplacements[m]; }); } + /** @param {string} docs */ function shortDescMarkdown(docs) { var parts = docs.trim().split("\n"); var firstLine = parts[0]; return markdown(firstLine); } + /** @param {string} input */ function markdown(input) { const raw_lines = input.split('\n'); // zig allows no '\r', so we don't need to split on CR + /** + * @type Array<{ + * indent: number, + * raw_text: string, + * text: string, + * type: string, + * ordered_number: number, + * }> + */ const lines = []; // PHASE 1: @@ -1941,6 +1969,7 @@ var zigAnalysis; raw_text: raw_line, text: raw_line.trim(), type: "p", // p, h1 … h6, code, ul, ol, blockquote, skip, empty + ordered_number: -1, // NOTE: hack to make the type checker happy }; if (!is_reading_code) { @@ -1977,7 +2006,7 @@ var zigAnalysis; line.text = line.text.substr(1); } else if (line.text.match(/^\d+\..*$/)) { // if line starts with {number}{dot} - const match = line.text.match(/(\d+)\./); + const match = /** @type {RegExpMatchArray} */(line.text.match(/(\d+)\./)); line.type = "ul"; line.text = line.text.substr(match[0].length); line.ordered_number = Number(match[1].length); @@ -2010,7 +2039,10 @@ var zigAnalysis; // Render HTML from markdown lines. // Look at each line and emit fitting HTML code - function markdownInlines(innerText, stopChar) { + /** + * @param {string } innerText + */ + function markdownInlines(innerText) { // inline types: // **{INLINE}** : @@ -2023,6 +2055,8 @@ var zigAnalysis; // ![{TEXT}]({URL}) : // [[std;format.fmt]] : (inner link) + /** @typedef {{marker: string, tag: string}} Fmt*/ + /** @type {Array} */ const formats = [ { marker: "**", @@ -2042,6 +2076,7 @@ var zigAnalysis; } ]; + /** @type {Array} */ const stack = []; var innerHTML = ""; @@ -2093,7 +2128,7 @@ var zigAnalysis; in_code = true; } else { var any = false; - for (var idx = (stack.length > 0 ? -1 : 0); idx < formats.length; idx++) { + for (let idx = /** @type {number} */(stack.length > 0 ? -1 : 0); idx < formats.length; idx++) { const fmt = idx >= 0 ? formats[idx] : stack[stack.length - 1]; if (innerText.substr(i, fmt.marker.length) == fmt.marker) { flushRun(); @@ -2117,48 +2152,60 @@ var zigAnalysis; flushRun(); while (stack.length > 0) { - const fmt = stack.pop(); + const fmt = /** @type {Fmt} */(stack.pop()); innerHTML += ""; } return innerHTML; } + /** + * @param {string} type + * @param {number} line_no + */ + function previousLineIs(type, line_no) { + if (line_no > 0) { + return (lines[line_no - 1].type == type); + } else { + return false; + } + } + + /** + * @param {string} type + * @param {number} line_no + */ + function nextLineIs(type, line_no) { + if (line_no < (lines.length - 1)) { + return (lines[line_no + 1].type == type); + } else { + return false; + } + } + + /** @param {number} line_no */ + function getPreviousLineIndent(line_no) { + if (line_no > 0) { + return lines[line_no - 1].indent; + } else { + return 0; + } + } + + /** @param {number} line_no */ + function getNextLineIndent(line_no) { + if (line_no < (lines.length - 1)) { + return lines[line_no + 1].indent; + } else { + return 0; + } + } + var html = ""; for (var line_no = 0; line_no < lines.length; line_no++) { const line = lines[line_no]; - function previousLineIs(type) { - if (line_no > 0) { - return (lines[line_no - 1].type == type); - } else { - return false; - } - } - function nextLineIs(type) { - if (line_no < (lines.length - 1)) { - return (lines[line_no + 1].type == type); - } else { - return false; - } - } - - function getPreviousLineIndent() { - if (line_no > 0) { - return lines[line_no - 1].indent; - } else { - return 0; - } - } - - function getNextLineIndent() { - if (line_no < (lines.length - 1)) { - return lines[line_no + 1].indent; - } else { - return 0; - } - } switch (line.type) { case "h1": @@ -2172,33 +2219,33 @@ var zigAnalysis; case "ul": case "ol": - if (!previousLineIs("ul") || getPreviousLineIndent() < line.indent) { + if (!previousLineIs("ul", line_no) || getPreviousLineIndent(line_no) < line.indent) { html += "<" + line.type + ">\n"; } html += "
  • " + markdownInlines(line.text) + "
    • \n"; - if (!nextLineIs("ul") || getNextLineIndent() < line.indent) { + if (!nextLineIs("ul", line_no) || getNextLineIndent(line_no) < line.indent) { html += "\n"; } break; case "p": - if (!previousLineIs("p")) { + if (!previousLineIs("p", line_no)) { html += "

    \n"; } html += markdownInlines(line.text) + "\n"; - if (!nextLineIs("p")) { + if (!nextLineIs("p", line_no)) { html += "

    \n"; } break; case "code": - if (!previousLineIs("code")) { + if (!previousLineIs("code", line_no)) { html += "
    ";
                     }
                     html += escapeHtml(line.text) + "\n";
-                    if (!nextLineIs("code")) {
+                    if (!nextLineIs("code", line_no)) {
                         html += "
    \n"; } break; @@ -2219,12 +2266,13 @@ var zigAnalysis; } if (liDom != null) { var aDom = liDom.children[0]; - location.href = aDom.getAttribute("href"); + location.href = /** @type {string} */(aDom.getAttribute("href")); curSearchIndex = -1; } domSearch.blur(); } + /** @param {KeyboardEvent} ev */ function onSearchKeyDown(ev) { switch (getKeyString(ev)) { case "Enter": @@ -2268,6 +2316,8 @@ var zigAnalysis; } } + + /** @param {number} dir */ function moveSearchCursor(dir) { if (curSearchIndex < 0 || curSearchIndex >= domListSearchResults.children.length) { if (dir > 0) { @@ -2287,6 +2337,7 @@ var zigAnalysis; renderSearchCursor(); } + /** @param {KeyboardEvent} ev */ function getKeyString(ev) { var name; var ignoreShift = false; @@ -2313,6 +2364,7 @@ var zigAnalysis; return name; } + /** @param {KeyboardEvent} ev */ function onWindowKeyDown(ev) { switch (getKeyString(ev)) { case "Esc": @@ -2451,7 +2503,7 @@ function renderSearch() { function renderSearchCursor() { for (var i = 0; i < domListSearchResults.children.length; i += 1) { - var liDom = domListSearchResults.children[i]; + var liDom = /** @type HTMLElement */(domListSearchResults.children[i]); if (curSearchIndex === i) { liDom.classList.add("selected"); } else { @@ -2462,35 +2514,42 @@ function renderSearchCursor() { -function indexNodesToCalls() { - var map = {}; - for (var i = 0; i < zigAnalysis.calls.length; i += 1) { - var call = zigAnalysis.calls[i]; - var fn = zigAnalysis.fns[call.fn]; - if (map[fn.src] == null) { - map[fn.src] = [i]; - } else { - map[fn.src].push(i); - } - } - return map; -} +// function indexNodesToCalls() { +// var map = {}; +// for (var i = 0; i < zigAnalysis.calls.length; i += 1) { +// var call = zigAnalysis.calls[i]; +// var fn = zigAnalysis.fns[call.fn]; +// if (map[fn.src] == null) { +// map[fn.src] = [i]; +// } else { +// map[fn.src].push(i); +// } +// } +// return map; +// } + +/** +* @param {{ name: string }} a +* @param {{ name: string }} b +*/ function byNameProperty(a, b) { return operatorCompare(a.name, b.name); } + +/** + * @template T + * @param {T} obj + * @returns {T} + */ function clone(obj) { - var res = {}; + var res = /** @type T */({}); for (var key in obj) { res[key] = obj[key]; } return res; } -function firstObjectKey(obj) { - for (var key in obj) { - return key; - } -} + })(); From 919b8e400ca7b2885221a4a93ba5ab3192046480 Mon Sep 17 00:00:00 2001 From: Loris Cro Date: Thu, 31 Mar 2022 19:07:57 +0200 Subject: [PATCH 046/137] autodoc: more typechecking in main.js --- lib/docs/main.js | 341 ++++++++++++++++++++++++++++------------------- 1 file changed, 204 insertions(+), 137 deletions(-) diff --git a/lib/docs/main.js b/lib/docs/main.js index 1966beb7a9..7247c43276 100644 --- a/lib/docs/main.js +++ b/lib/docs/main.js @@ -56,32 +56,40 @@ */ /** - * @typedef { - | { kind: number, name: string; src: number; privDecls: number[]; pubDecls: number[]; fields: WalkResult[] } // Struct, Enum, Union - } ContainerType -*/ - -/** - * @typedef { - | { kind: number, name: string } // Type, Void, Bool, NoReturn, Int, Float, ComptimeExpr, ComptimeFloat, ComptimeInt, Undefined, Null, ErrorUnion, BoundFn, Opaque, Frame, AnyFrame, Vector, EnumLiteral - | { kind: number, name: string; child: TypeRef } // Optional - | { kind: number, len: WalkResult; child: TypeRef } // Array - | { kind: number, name: string; fields: { name: string; docs: string }[] } // ErrorSet - | { kind: number, size: "One" | "Many" | "Slice" | "C"; child: TypeRef } // Pointer - | ContainerType - | { kind: number, name: string; src: number; ret: WalkResult; params: WalkResult[] } // Fn - } Type + * @typedef {{ + kind: number, + name: string, + src: number, + privDecls: number[], + pubDecls: number[], + fields: WalkResult[] +}} ContainerType */ /** * @typedef {{ - name: string, - src: number | null, - ret: WalkResult, - params: WalkResult[] | null, - }} Fn + kind: number, + name: string, + src: number, + ret: WalkResult, + params: WalkResult[] + }} Fn */ + +/** + * @typedef { + | { kind: number, name: string } // Type, Void, Bool, NoReturn, Int, Float, ComptimeExpr, ComptimeFloat, ComptimeInt, Undefined, Null, ErrorUnion, BoundFn, Opaque, Frame, AnyFrame, Vector, EnumLiteral + | { kind: number, name: string; child: WalkResult } // Optional + | { kind: number, len: WalkResult; child: WalkResult } // Array + | { kind: number, name: string; fields: { name: string; docs: string }[] } // ErrorSet + | { kind: number, size: "One" | "Many" | "Slice" | "C"; child: WalkResult } // Pointer + | ContainerType + | Fn + } Type +*/ + + /** * @typedef {{ func: WalkResult, @@ -109,6 +117,7 @@ src: number, value: WalkResult, decltest?: number, + isTest: bool, }} Decl */ @@ -117,7 +126,7 @@ name: string, file: number, main: number, - table: { root: number }, + table: Record, }} Package */ @@ -225,17 +234,34 @@ var zigAnalysis; /** @type Object */ var escapeHtmlReplacements = { "&": "&", '"': """, "<": "<", ">": ">" }; - var typeKinds = indexTypeKinds(); - var typeTypeId = findTypeTypeId(); + var typeKinds = /** @type {Record} */(indexTypeKinds()); + var typeTypeId = /** @type {number} */ (findTypeTypeId()); var pointerSizeEnum = { One: 0, Many: 1, Slice: 2, C: 3 }; // for each package, is an array with packages to get to this one var canonPkgPaths = computeCanonicalPackagePaths(); + + /** @typedef {{declNames: string[], pkgNames: string[]}} CanonDecl */ + // for each decl, is an array with {declNames, pkgNames} to get to this one + /** @type CanonDecl[] | null */ var canonDeclPaths = null; // lazy; use getCanonDeclPath + // for each type, is an array with {declNames, pkgNames} to get to this one + /** @type number[] | null */ var canonTypeDecls = null; // lazy; use getCanonTypeDecl + /** @typedef {{ + * showPrivDecls: bool, + * pkgNames: string[], + * pkgObjs: Package[], + * declNames: string[], + * declObjs: Decl[], + * callName: any, + * }} CurNav + */ + + /** @type {CurNav} */ var curNav = { showPrivDecls: false, // each element is a package name, e.g. @import("a") then within there @import("b") @@ -252,6 +278,7 @@ var zigAnalysis; // (a, b, c, d) comptime call; result is the value the docs refer to callName: null, }; + var curNavSearch = ""; var curSearchIndex = -1; var imFeelingLucky = false; @@ -606,7 +633,7 @@ var zigAnalysis; if (instantiations == null && calls == null) { domFnNoExamples.classList.remove("hidden"); } else if (calls != null) { - if (fnObj.combined === undefined) fnObj.combined = allCompTimeFnCallsResult(calls); + // if (fnObj.combined === undefined) fnObj.combined = allCompTimeFnCallsResult(calls); if (fnObj.combined != null) renderContainer(fnObj.combined); resizeDomList(domListFnExamples, calls.length, '
  • '); @@ -848,6 +875,14 @@ var zigAnalysis; } } + /** + * @param {WalkResult} typeValue, + * @param {boolean} wantHtml, + * @param {boolean} wantLink, + * @param {number} [fnDecl], + * @param {string} [linkFnNameDecl], + * @return {string} + */ function typeValueName(typeValue, wantHtml, wantLink, fnDecl, linkFnNameDecl) { if ("int" in typeValue) { @@ -984,6 +1019,14 @@ var zigAnalysis; } } + /** + * @param {Type} typeObj, + * @param {boolean} wantHtml, + * @param {boolean} wantSubLink, + * @param {number} [fnDecl], + * @param {string} [linkFnNameDecl], + * @return {string} + */ function typeName(typeObj, wantHtml, wantSubLink, fnDecl, linkFnNameDecl) { switch (typeObj.kind) { case typeKinds.Array: @@ -1294,111 +1337,113 @@ var zigAnalysis; domSectFnErrors.classList.remove("hidden"); } - function allCompTimeFnCallsHaveTypeResult(typeIndex, value) { - var srcIndex = zigAnalysis.fns[value].src; - var calls = nodesToCallsMap[srcIndex]; - if (calls == null) return false; - for (var i = 0; i < calls.length; i += 1) { - var call = zigAnalysis.calls[calls[i]]; - if (call.result.type !== typeTypeId) return false; - } - return true; - } +// function allCompTimeFnCallsHaveTypeResult(typeIndex, value) { +// var srcIndex = zigAnalysis.fns[value].src; +// var calls = nodesToCallsMap[srcIndex]; +// if (calls == null) return false; +// for (var i = 0; i < calls.length; i += 1) { +// var call = zigAnalysis.calls[calls[i]]; +// if (call.result.type !== typeTypeId) return false; +// } +// return true; +// } +// +// function allCompTimeFnCallsResult(calls) { +// var firstTypeObj = null; +// var containerObj = { +// privDecls: [], +// }; +// for (var callI = 0; callI < calls.length; callI += 1) { +// var call = zigAnalysis.calls[calls[callI]]; +// if (call.result.type !== typeTypeId) return null; +// var typeObj = zigAnalysis.types[call.result.value]; +// if (!typeKindIsContainer(typeObj.kind)) return null; +// if (firstTypeObj == null) { +// firstTypeObj = typeObj; +// containerObj.src = typeObj.src; +// } else if (firstTypeObj.src !== typeObj.src) { +// return null; +// } +// +// if (containerObj.fields == null) { +// containerObj.fields = (typeObj.fields || []).concat([]); +// } else for (var fieldI = 0; fieldI < typeObj.fields.length; fieldI += 1) { +// var prev = containerObj.fields[fieldI]; +// var next = typeObj.fields[fieldI]; +// if (prev === next) continue; +// if (typeof(prev) === 'object') { +// if (prev[next] == null) prev[next] = typeObj; +// } else { +// containerObj.fields[fieldI] = {}; +// containerObj.fields[fieldI][prev] = firstTypeObj; +// containerObj.fields[fieldI][next] = typeObj; +// } +// } +// +// if (containerObj.pubDecls == null) { +// containerObj.pubDecls = (typeObj.pubDecls || []).concat([]); +// } else for (var declI = 0; declI < typeObj.pubDecls.length; declI += 1) { +// var prev = containerObj.pubDecls[declI]; +// var next = typeObj.pubDecls[declI]; +// if (prev === next) continue; +// // TODO instead of showing "examples" as the public declarations, +// // do logic like this: +// //if (typeof(prev) !== 'object') { +// // var newDeclId = zigAnalysis.decls.length; +// // prev = clone(zigAnalysis.decls[prev]); +// // prev.id = newDeclId; +// // zigAnalysis.decls.push(prev); +// // containerObj.pubDecls[declI] = prev; +// //} +// //mergeDecls(prev, next, firstTypeObj, typeObj); +// } +// } +// for (var declI = 0; declI < containerObj.pubDecls.length; declI += 1) { +// var decl = containerObj.pubDecls[declI]; +// if (typeof(decl) === 'object') { +// containerObj.pubDecls[declI] = containerObj.pubDecls[declI].id; +// } +// } +// return containerObj; +// } - function allCompTimeFnCallsResult(calls) { - var firstTypeObj = null; - var containerObj = { - privDecls: [], - }; - for (var callI = 0; callI < calls.length; callI += 1) { - var call = zigAnalysis.calls[calls[callI]]; - if (call.result.type !== typeTypeId) return null; - var typeObj = zigAnalysis.types[call.result.value]; - if (!typeKindIsContainer(typeObj.kind)) return null; - if (firstTypeObj == null) { - firstTypeObj = typeObj; - containerObj.src = typeObj.src; - } else if (firstTypeObj.src !== typeObj.src) { - return null; - } - if (containerObj.fields == null) { - containerObj.fields = (typeObj.fields || []).concat([]); - } else for (var fieldI = 0; fieldI < typeObj.fields.length; fieldI += 1) { - var prev = containerObj.fields[fieldI]; - var next = typeObj.fields[fieldI]; - if (prev === next) continue; - if (typeof(prev) === 'object') { - if (prev[next] == null) prev[next] = typeObj; - } else { - containerObj.fields[fieldI] = {}; - containerObj.fields[fieldI][prev] = firstTypeObj; - containerObj.fields[fieldI][next] = typeObj; - } - } - - if (containerObj.pubDecls == null) { - containerObj.pubDecls = (typeObj.pubDecls || []).concat([]); - } else for (var declI = 0; declI < typeObj.pubDecls.length; declI += 1) { - var prev = containerObj.pubDecls[declI]; - var next = typeObj.pubDecls[declI]; - if (prev === next) continue; - // TODO instead of showing "examples" as the public declarations, - // do logic like this: - //if (typeof(prev) !== 'object') { - // var newDeclId = zigAnalysis.decls.length; - // prev = clone(zigAnalysis.decls[prev]); - // prev.id = newDeclId; - // zigAnalysis.decls.push(prev); - // containerObj.pubDecls[declI] = prev; - //} - //mergeDecls(prev, next, firstTypeObj, typeObj); - } - } - for (var declI = 0; declI < containerObj.pubDecls.length; declI += 1) { - var decl = containerObj.pubDecls[declI]; - if (typeof(decl) === 'object') { - containerObj.pubDecls[declI] = containerObj.pubDecls[declI].id; - } - } - return containerObj; - } - - function mergeDecls(declObj, nextDeclIndex, firstTypeObj, typeObj) { - var nextDeclObj = zigAnalysis.decls[nextDeclIndex]; - if (declObj.type != null && nextDeclObj.type != null && declObj.type !== nextDeclObj.type) { - if (typeof(declObj.type) !== 'object') { - var prevType = declObj.type; - declObj.type = {}; - declObj.type[prevType] = firstTypeObj; - declObj.value = null; - } - declObj.type[nextDeclObj.type] = typeObj; - } else if (declObj.type == null && nextDeclObj != null) { - declObj.type = nextDeclObj.type; - } - if (declObj.value != null && nextDeclObj.value != null && declObj.value !== nextDeclObj.value) { - if (typeof(declObj.value) !== 'object') { - var prevValue = declObj.value; - declObj.value = {}; - declObj.value[prevValue] = firstTypeObj; - } - declObj.value[nextDeclObj.value] = typeObj; - } else if (declObj.value == null && nextDeclObj.value != null) { - declObj.value = nextDeclObj.value; - } - } + // function mergeDecls(declObj, nextDeclIndex, firstTypeObj, typeObj) { + // var nextDeclObj = zigAnalysis.decls[nextDeclIndex]; + // if (declObj.type != null && nextDeclObj.type != null && declObj.type !== nextDeclObj.type) { + // if (typeof(declObj.type) !== 'object') { + // var prevType = declObj.type; + // declObj.type = {}; + // declObj.type[prevType] = firstTypeObj; + // declObj.value = null; + // } + // declObj.type[nextDeclObj.type] = typeObj; + // } else if (declObj.type == null && nextDeclObj != null) { + // declObj.type = nextDeclObj.type; + // } + // if (declObj.value != null && nextDeclObj.value != null && declObj.value !== nextDeclObj.value) { + // if (typeof(declObj.value) !== 'object') { + // var prevValue = declObj.value; + // declObj.value = {}; + // declObj.value[prevValue] = firstTypeObj; + // } + // declObj.value[nextDeclObj.value] = typeObj; + // } else if (declObj.value == null && nextDeclObj.value != null) { + // declObj.value = nextDeclObj.value; + // } + // } + /** @param {Decl} decl */ function renderValue(decl) { var declTypeRef = typeOfDecl(decl); var declValueText = ""; switch(Object.keys(decl.value)[0]) { case "int": - declValueText += decl.value.int.value; + declValueText += /** @type {{int: {value: number}}} */(decl.value).int.value; break; case "float": - declValueText += decl.value.float.value; + declValueText += /** @type {{float: {value: number}}} */(decl.value).float.value; break; case "comptimeExpr": declValueText += "[ComptimeExpr]"; @@ -1421,6 +1466,7 @@ var zigAnalysis; domFnProto.classList.remove("hidden"); } + /** @param {Decl} decl */ function renderVar(decl) { var declTypeRef = typeOfDecl(decl); domFnProtoCode.innerHTML = 'var ' + @@ -1438,7 +1484,13 @@ var zigAnalysis; /** * @param {number[]} decls - * @param {Decl[]} typesList, namespacesList, errSetsList, fnsList, varsList, valsList, testsList + * @param {Decl[]} typesList + * @param {Decl[]} namespacesList, + * @param {Decl[]} errSetsList, + * @param {Decl[]} fnsList, + * @param {Decl[]} varsList, + * @param {Decl[]} valsList, + * @param {Decl[]} testsList */ function categorizeDecls(decls, typesList, namespacesList, errSetsList, @@ -1482,7 +1534,7 @@ var zigAnalysis; var kind = value.kind; if (kind === typeKinds.Fn) { // TODO: handle CTE return types when we know their type. - const resVal = resolveValue(value.ret); + const resVal = resolveValue(/** @type {Fn} */(value).ret); if ("type" in resVal && resVal.type == typeTypeId) { typesList.push(decl); } else { @@ -1610,20 +1662,17 @@ var zigAnalysis; for (var i = 0; i < containerNode.fields.length; i += 1) { var fieldNode = zigAnalysis.astNodes[containerNode.fields[i]]; var divDom = domListFields.children[i]; + let fieldName = /** @type {string} */(fieldNode.name); - var html = '
    ' + escapeHtml(fieldNode.name);
+                var html = '
    ' + escapeHtml(fieldName);
 
                 if (container.kind === typeKinds.Enum) {
-                    html += ' = ' + field + '';
+                    html += ' = ' + fieldName + '';
                 } else {
                     var field = container.fields[i];
                     html += ": ";
-                    if (field.failure === true) {
-                        html += '#FAILURE#';
-                    } else {
-                        var name = typeValueName(field);
-                        html += ''+ name +'';
-                    }
+                    var name = typeValueName(field);
+                    html += ''+ name +'';
                 }
 
                 html += ',
    ';
@@ -1719,6 +1768,11 @@ var zigAnalysis;
         }
     }
 
+
+    /**
+    * @param {string | number} a
+    * @param {string | number} b
+    */
     function operatorCompare(a, b) {
         if (a === b) {
             return 0;
@@ -1741,7 +1795,7 @@ var zigAnalysis;
     }
 
     function indexTypeKinds() {
-        var map = {};
+        var map = /** @type {Record} */({});
         for (var i = 0; i < zigAnalysis.typeKinds.length; i += 1) {
             map[zigAnalysis.typeKinds[i]] = i;
         }
@@ -1765,12 +1819,14 @@ var zigAnalysis;
     }
 
     function updateCurNav() {
+
         curNav = {
             showPrivDecls: false,
             pkgNames: [],
             pkgObjs: [],
             declNames: [],
             declObjs: [],
+            callName: null,
         };
         curNavSearch = "";
 
@@ -1814,6 +1870,10 @@ var zigAnalysis;
         }
     }
 
+    /**
+    * @param {ContainerType} parentType
+    * @param {string} childName
+    */
     function findSubDecl(parentType, childName) {
         if (!parentType.pubDecls) return null;
         for (var i = 0; i < parentType.pubDecls.length; i += 1) {
@@ -1843,11 +1903,11 @@ var zigAnalysis;
             var rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
         // Breadth-first to keep the path shortest possible.
             var stack = [{
-                path: [],
+                path: /** @type {string[]} */([]),
                 pkg: rootPkg,
             }];
         while (stack.length !== 0) {
-            var item = stack.shift();
+            var item = /** @type {{path: string[], pkg: Package}} */(stack.shift());
             for (var key in item.pkg.table) {
                 var childPkgIndex = item.pkg.table[key];
                 if (list[childPkgIndex] != null) continue;
@@ -1866,6 +1926,7 @@ var zigAnalysis;
     }
 
 
+    /** @return {CanonDecl[]} */
     function computeCanonDeclPaths() {
         var list = new Array(zigAnalysis.decls.length);
         canonTypeDecls = new Array(zigAnalysis.types.length);
@@ -1875,16 +1936,18 @@ var zigAnalysis;
             var pkg = zigAnalysis.packages[pkgI];
             var pkgNames = canonPkgPaths[pkgI];
             var stack = [{
-                declNames: [],
+                declNames: /** @type {string[]} */([]),
                 type: zigAnalysis.types[pkg.main],
             }];
             while (stack.length !== 0) {
-                var item = stack.shift();
+                var item = /** @type {{declNames: string[], type: Type}} */(stack.shift());
 
                 if (isContainerType(item.type)) {
-                    var len = item.type.pubDecls ? item.type.pubDecls.length : 0;
+                    let t = /** @type {ContainerType} */(item.type);
+
+                    var len = t.pubDecls ? t.pubDecls.length : 0;
                     for (var declI = 0; declI < len; declI += 1) {
-                        var mainDeclIndex = item.type.pubDecls[declI];
+                        var mainDeclIndex = t.pubDecls[declI];
                         if (list[mainDeclIndex] != null) continue;
 
                         var decl = zigAnalysis.decls[mainDeclIndex];
@@ -1915,16 +1978,20 @@ var zigAnalysis;
         return list;
     }
 
+    /** @param {number} index */
     function getCanonDeclPath(index) {
         if (canonDeclPaths == null) {
             canonDeclPaths = computeCanonDeclPaths();
         }
-        return canonDeclPaths[index];
+        let cd = /** @type {CanonDecl[]}*/(canonDeclPaths);
+        return cd[index];
     }
 
+    /** @param {number} index */
     function getCanonTypeDecl(index) {
         getCanonDeclPath(0);
-        return canonTypeDecls[index];
+        let ct = /** @type {number[]}*/(canonTypeDecls);
+        return ct[index];
     }
 
     /** @param {string} text */

From 80f9490e06c6190d176263ec6e7956a0d4b7887d Mon Sep 17 00:00:00 2001
From: Loris Cro 
Date: Fri, 1 Apr 2022 19:41:43 +0200
Subject: [PATCH 047/137] autodoc: more js type fixes

---
 lib/docs/main.js | 388 +++++++++++++++++++++++++++++++----------------
 src/Autodoc.zig  |   1 +
 2 files changed, 255 insertions(+), 134 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 7247c43276..1335bcce2d 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -33,26 +33,27 @@
 */
 
 /**
- * @typedef {
-    | { void: {} }
-    | { unreachable: {} }
-    | { anytype: {} }
-    | { type: number }
-    | { comptimeExpr: number }
-    | { call: number }
-    | { int: { typeRef: WalkResult; value: number } }
-    | { float: { typeRef: WalkResult; value: number } }
-    | { bool: boolean }
-    | { undefined: WalkResult }
-    | { null: WalkResult }
-    | { typeOf: WalkResult }
-    | { compileError: string }
-    | { string: string }
-    | { struct: Struct }
-    | { refPath: WalkResult[] }
-    | { array: ZigArray }
-    | { enumLiteral: string }
-   } WalkResult
+ * @typedef {{
+     void: {},
+     unreachable: {},
+     anytype: {},
+     type: number,
+     comptimeExpr: number,
+     call: number,
+     int: { typeRef: WalkResult; value: number },
+     float: { typeRef: WalkResult; value: number },
+     bool: boolean,
+     undefined: WalkResult,
+     null: WalkResult,
+     typeOf: WalkResult,
+     compileError: string,
+     string: string,
+     struct: Struct,
+     refPath: WalkResult[],
+     declRef: number,
+     array: ZigArray,
+     enumLiteral: string,
+   }} WalkResult
 */
 
 /**
@@ -76,16 +77,70 @@
  }} Fn
 */
 
+/**
+* @typedef {{
+     kind: number,
+     name: string,
+     fields: { name: string, docs: string }[]
+     fn: number | undefined,
+}} ErrSetType
+*/
+
+/**
+* @typedef {{
+     kind: number,
+     err: WalkResult,
+     payload: WalkResult,
+}} ErrUnionType
+*/
+
+// Type, Void, Bool, NoReturn, Int, Float, ComptimeExpr, ComptimeFloat, ComptimeInt, Undefined, Null, ErrorUnion, BoundFn, Opaque, Frame, AnyFrame, Vector, EnumLiteral
+/**
+* @typedef {{
+     kind: number,
+     name: string
+}} NumberType
+*/
+
+/**
+* @typedef {{
+     kind: number,
+     size: number,
+     child: WalkResult
+     align: number,
+     bitOffsetInHost: number,
+     hostIntBytes: number,
+     volatile: boolean,
+     const: boolean,
+}} PointerType
+*/
+
+/**
+* @typedef {{
+     kind: number,
+     len: WalkResult
+     child: WalkResult
+}} ArrayType
+*/
+
+/**
+* @typedef {{
+     kind: number,
+     name: string,
+     child: WalkResult
+}} OptionalType
+*/
 
 /**
  * @typedef {
-    | { kind: number, name: string } // Type, Void, Bool, NoReturn, Int, Float, ComptimeExpr, ComptimeFloat, ComptimeInt, Undefined, Null, ErrorUnion, BoundFn, Opaque, Frame, AnyFrame, Vector, EnumLiteral
-    | { kind: number, name: string; child: WalkResult } // Optional
-    | { kind: number, len: WalkResult; child: WalkResult } // Array
-    | { kind: number, name: string; fields: { name: string; docs: string }[] } // ErrorSet
-    | { kind: number, size: "One" | "Many" | "Slice" | "C"; child: WalkResult } // Pointer
+    | OptionalType
+    | ArrayType
+    | PointerType
     | ContainerType
     | Fn
+    | ErrSetType
+    | ErrUnionType
+    | NumberType
    } Type
 */
 
@@ -107,6 +162,8 @@
        docs?: string,
        fields?: number[],
        comptime: boolean,
+       noalias: boolean,
+       varArgs: boolean,
    }} AstNode
 */
 
@@ -117,7 +174,7 @@
       src: number,
       value: WalkResult,
       decltest?: number,
-      isTest: bool,
+      isTest: boolean,
    }} Decl
 */
 
@@ -223,7 +280,7 @@ var zigAnalysis;
     var domSectSearchNoResults = /** @type HTMLElement */(document.getElementById("sectSearchNoResults"));
     var domSectInfo = /** @type HTMLElement */(document.getElementById("sectInfo"));
     var domTdTarget = /** @type HTMLElement */(document.getElementById("tdTarget"));
-    var domPrivDeclsBox = /** @type HTMLElement */(document.getElementById("privDeclsBox"));
+    var domPrivDeclsBox = /** @type HTMLCheckboxElement */(document.getElementById("privDeclsBox"));
     var domTdZigVer = /** @type HTMLElement */(document.getElementById("tdZigVer"));
     var domHdrName = /** @type HTMLElement */(document.getElementById("hdrName"));
     var domHelpModal = /** @type HTMLElement */(document.getElementById("helpDialog"));
@@ -252,7 +309,7 @@ var zigAnalysis;
     var canonTypeDecls = null; // lazy; use getCanonTypeDecl
 
     /** @typedef {{
-    *       showPrivDecls: bool,
+    *       showPrivDecls: boolean,
     *       pkgNames: string[],
     *       pkgObjs: Package[],
     *       declNames: string[],
@@ -598,6 +655,7 @@ var zigAnalysis;
         return typeObj.generic;
     }
 
+    /** @param {Decl} fnDecl */
     function renderFn(fnDecl) {
         var value = resolveValue(fnDecl.value);
         console.assert("type" in value);
@@ -622,31 +680,32 @@ var zigAnalysis;
             errSetTypeIndex = retType.err;
         }
         if (errSetTypeIndex != null) {
-            var errSetType = zigAnalysis.types[errSetTypeIndex];
+            var errSetType = /** @type {ErrSetType} */(zigAnalysis.types[errSetTypeIndex]);
             renderErrorSet(errSetType);
         }
 
         var protoSrcIndex = fnDecl.src;
         if (typeIsGenericFn(value.type)) {
-            var instantiations = nodesToFnsMap[protoSrcIndex];
-            var calls = nodesToCallsMap[protoSrcIndex];
-            if (instantiations == null && calls == null) {
-                domFnNoExamples.classList.remove("hidden");
-            } else if (calls != null) {
-                // if (fnObj.combined === undefined) fnObj.combined = allCompTimeFnCallsResult(calls);
-                if (fnObj.combined != null) renderContainer(fnObj.combined);
+            throw "TODO";
+            // var instantiations = nodesToFnsMap[protoSrcIndex];
+            // var calls = nodesToCallsMap[protoSrcIndex];
+            // if (instantiations == null && calls == null) {
+            //     domFnNoExamples.classList.remove("hidden");
+            // } else if (calls != null) {
+            //     // if (fnObj.combined === undefined) fnObj.combined = allCompTimeFnCallsResult(calls);
+            //     if (fnObj.combined != null) renderContainer(fnObj.combined);
 
-                resizeDomList(domListFnExamples, calls.length, '
  • ');
+            //     resizeDomList(domListFnExamples, calls.length, '
  • ');
 
-                for (var callI = 0; callI < calls.length; callI += 1) {
-                    var liDom = domListFnExamples.children[callI];
-                    liDom.innerHTML = getCallHtml(fnDecl, calls[callI]);
-                }
+            //     for (var callI = 0; callI < calls.length; callI += 1) {
+            //         var liDom = domListFnExamples.children[callI];
+            //         liDom.innerHTML = getCallHtml(fnDecl, calls[callI]);
+            //     }
 
-                domFnExamples.classList.remove("hidden");
-            } else if (instantiations != null) {
-                // TODO
-            }
+            //     domFnExamples.classList.remove("hidden");
+            // } else if (instantiations != null) {
+            //     // TODO
+            // }
         } else {
 
             domFnExamples.classList.add("hidden");
@@ -664,11 +723,15 @@ var zigAnalysis;
         domFnProto.classList.remove("hidden");
     }
 
+    /**
+    * @param {Decl} fnDecl
+    * @param {Fn} typeObj
+    */
     function renderFnParamDocs(fnDecl, typeObj) {
         var docCount = 0;
 
         var fnNode = zigAnalysis.astNodes[fnDecl.src];
-        var fields = fnNode.fields;
+        var fields = /** @type {number[]} */(fnNode.fields);
         var isVarArgs = fnNode.varArgs;
 
         for (var i = 0; i < fields.length; i += 1) {
@@ -696,11 +759,11 @@ var zigAnalysis;
 
 
             var value = typeObj.params[i];
-            var html = '
    ' + escapeHtml(fieldNode.name) + ": ";
+            var html = '
    ' + escapeHtml(/** @type {string} */(fieldNode.name)) + ": ";
             if (isVarArgs && i === typeObj.params.length - 1) {
                 html += '...';
             } else {
-                var name = typeValueName(value);
+                var name = typeValueName(value, false, false);
                 html += '' + name + '';
             }
 
@@ -720,7 +783,7 @@ var zigAnalysis;
         resizeDomList(domListNav, len, '
    • ');
         var list = [];
         var hrefPkgNames = [];
-        var hrefDeclNames = [];
+        var hrefDeclNames = /** @type {string[]} */([]);
         for (var i = 0; i < curNav.pkgNames.length; i += 1) {
             hrefPkgNames.push(curNav.pkgNames[i]);
             list.push({
@@ -753,7 +816,7 @@ var zigAnalysis;
 
     function renderInfo() {
         domTdZigVer.textContent = zigAnalysis.params.zigVersion;
-        domTdTarget.textContent = zigAnalysis.params.builds[0].target;
+        //domTdTarget.textContent = zigAnalysis.params.builds[0].target;
 
         domSectInfo.classList.remove("hidden");
     }
@@ -809,6 +872,12 @@ var zigAnalysis;
         }
     }
 
+    /**
+    * @param {string[]} pkgNames
+    * @param {string[]} declNames
+    * @param {string} [callName]
+    */
+
     function navLink(pkgNames, declNames, callName) {
         let base = '#';
         if (curNav.showPrivDecls) {
@@ -826,23 +895,26 @@ var zigAnalysis;
         }
     }
 
+    /** @param {number} pkgIndex */
     function navLinkPkg(pkgIndex) {
         return navLink(canonPkgPaths[pkgIndex], []);
     }
 
+    /** @param {string} childName */
     function navLinkDecl(childName) {
         return navLink(curNav.pkgNames, curNav.declNames.concat([childName]));
     }
 
+    /** @param {Call} callObj */
     function navLinkCall(callObj) {
         var declNamesCopy = curNav.declNames.concat([]);
-        var callName = declNamesCopy.pop();
+        var callName = /** @type {string} */(declNamesCopy.pop());
 
         callName += '(';
             for (var arg_i = 0; arg_i < callObj.args.length; arg_i += 1) {
                 if (arg_i !== 0) callName += ',';
                 var argObj = callObj.args[arg_i];
-                callName += getValueText(argObj.type, argObj.value, false, false);
+                callName += getValueText(argObj, argObj, false, false);
             }
             callName += ')';
 
@@ -850,6 +922,10 @@ var zigAnalysis;
         return navLink(curNav.pkgNames, declNamesCopy);
     }
 
+    /**
+    * @param {any} dlDom
+    * @param {number} desiredLen
+    */
     function resizeDomListDl(dlDom, desiredLen) {
         // add the missing dom entries
         var i, ev;
@@ -863,6 +939,11 @@ var zigAnalysis;
         }
     }
 
+    /**
+    * @param {any} listDom
+    * @param {number} desiredLen
+    * @param {string} templateHtml
+    */
     function resizeDomList(listDom, desiredLen, templateHtml) {
         // add the missing dom entries
         var i, ev;
@@ -879,14 +960,14 @@ var zigAnalysis;
     * @param {WalkResult} typeValue,
     * @param {boolean} wantHtml,
     * @param {boolean} wantLink,
-    * @param {number} [fnDecl],
+    * @param {Decl | null} [fnDecl],
     * @param {string} [linkFnNameDecl],
     * @return {string}
     */
     function typeValueName(typeValue, wantHtml, wantLink, fnDecl, linkFnNameDecl) {
 
         if ("int" in typeValue) {
-            return typeValue.int.value;
+            return "" + typeValue.int.value;
         }
         if ("call" in typeValue) {
             var result = "";
@@ -963,38 +1044,51 @@ var zigAnalysis;
         }
     }
 
+    /**
+    * @param {WalkResult} typeRef
+    * @param {string} paramName
+    */
     function shouldSkipParamName(typeRef, paramName) {
         var resolvedTypeRef = resolveValue(typeRef);
         if ("type" in resolvedTypeRef) {
             var typeObj = zigAnalysis.types[resolvedTypeRef.type];
-            if (typeObj.kind === typeKinds.Pointer &&
-                  getPtrSize(typeObj) === pointerSizeEnum.One) {
-                const value = resolveValue(typeObj.child);
-                return typeValueName(value, false, true).toLowerCase() === paramName;
+            if (typeObj.kind === typeKinds.Pointer){
+                let ptrObj = /** @type {PointerType} */(typeObj);
+                if (getPtrSize(ptrObj) === pointerSizeEnum.One) {
+                    const value = resolveValue(ptrObj.child);
+                    return typeValueName(value, false, true).toLowerCase() === paramName;
+                }
             }
         }
         return false;
     }
 
+    /** @param {PointerType} typeObj */
     function getPtrSize(typeObj) {
-        return (typeObj.len == null) ? pointerSizeEnum.One : typeObj.len;
+        return (typeObj.size == null) ? pointerSizeEnum.One : typeObj.size;
     }
 
-    function getCallHtml(fnDecl, callIndex) {
-        var callObj = zigAnalysis.calls[callIndex];
+    // function getCallHtml(fnDecl, callIndex) {
+    //     var callObj = zigAnalysis.calls[callIndex];
 
-        // TODO make these links work
-        //var html = '' + escapeHtml(fnDecl.name) + '(';
-            var html = escapeHtml(fnDecl.name) + '(';
-                for (var arg_i = 0; arg_i < callObj.args.length; arg_i += 1) {
-                    if (arg_i !== 0) html += ', ';
-                    var argObj = callObj.args[arg_i];
-                    html += getValueText(argObj, argObj.value, true, true);
-                }
-                html += ')';
-            return html;
-        }
+    //     // TODO make these links work
+    //     //var html = '' + escapeHtml(fnDecl.name) + '(';
+    //         var html = escapeHtml(fnDecl.name) + '(';
+    //             for (var arg_i = 0; arg_i < callObj.args.length; arg_i += 1) {
+    //                 if (arg_i !== 0) html += ', ';
+    //                 var argObj = callObj.args[arg_i];
+    //                 html += getValueText(argObj, argObj.value, true, true);
+    //             }
+    //             html += ')';
+    //         return html;
+    //     }
 
+    /**
+    * @param {WalkResult} typeRef
+    * @param {any} value
+    * @param {boolean} wantHtml
+    * @param {boolean} wantLink
+    */
     function getValueText(typeRef, value, wantHtml, wantLink) {
         var resolvedTypeRef = resolveValue(typeRef);
         if ("comptimeExpr" in resolvedTypeRef) {
@@ -1004,10 +1098,10 @@ var zigAnalysis;
         var typeObj = zigAnalysis.types[typeRef.type];
         switch (typeObj.kind) {
             case typeKinds.Type:
-                return typeIndexName(value, wantHtml, wantLink);
+                return typeValueName(value, wantHtml, wantLink);
             case typeKinds.Fn:
                 var fnObj = zigAnalysis.fns[value];
-                return typeValueName(fnObj, wantHtml, wantLink);
+                return typeName(fnObj, wantHtml, wantLink);
             case typeKinds.Int:
                 if (wantHtml) {
                     return '' + value + '';
@@ -1023,29 +1117,34 @@ var zigAnalysis;
     * @param {Type} typeObj,
     * @param {boolean} wantHtml,
     * @param {boolean} wantSubLink,
-    * @param {number} [fnDecl],
+    * @param {Decl | null} [fnDecl],
     * @param {string} [linkFnNameDecl],
     * @return {string}
     */
     function typeName(typeObj, wantHtml, wantSubLink, fnDecl, linkFnNameDecl) {
         switch (typeObj.kind) {
             case typeKinds.Array:
+            {
+                let arrayObj = /** @type {ArrayType} */(typeObj);
                 var name = "[";
-                var lenName = typeValueName(typeObj.len, wantHtml);
+                var lenName = typeValueName(arrayObj.len, wantHtml, wantSubLink);
                 if (wantHtml) {
                     name += '' + lenName + '';
                 } else {
                     name += lenName;
                 }
                 name += "]";
-                name += typeValueName(typeObj.child, wantHtml, wantSubLink, null);
+                name += typeValueName(arrayObj.child, wantHtml, wantSubLink, null);
                 return name;
+            }
             case typeKinds.Optional:
 
-                return "?" + typeValueName(typeObj.child, wantHtml, wantSubLink, fnDecl, linkFnNameDecl);
+                return "?" + typeValueName(/**@type {OptionalType} */(typeObj).child, wantHtml, wantSubLink, fnDecl, linkFnNameDecl);
             case typeKinds.Pointer:
-                    var name = "";
-                switch (typeObj.size) {
+            {
+                let ptrObj = /** @type {PointerType} */(typeObj);
+                var name = "";
+                switch (ptrObj.size) {
                     default:
                         console.log("TODO: implement unhandled pointer size case");
                     case pointerSizeEnum.One:
@@ -1061,62 +1160,70 @@ var zigAnalysis;
                         name += "[*c]";
                         break;
                 }
-                if (typeObj['const']) {
+                if (ptrObj['const']) {
                     if (wantHtml) {
                         name += 'const ';
                     } else {
                         name += "const ";
                     }
                 }
-                if (typeObj['volatile']) {
+                if (ptrObj['volatile']) {
                     if (wantHtml) {
                         name += 'volatile ';
                     } else {
                         name += "volatile ";
                     }
                 }
-                if (typeObj.align != null) {
+                if (ptrObj.align != null) {
                     if (wantHtml) {
                         name += 'align(';
                     } else {
                         name += "align(";
                     }
                     if (wantHtml) {
-                        name += '' + typeObj.align + '';
+                        name += '' + ptrObj.align + '';
                     } else {
-                        name += typeObj.align;
+                        name += ptrObj.align;
                     }
-                    if (typeObj.hostIntBytes != null) {
+                    if (ptrObj.hostIntBytes != null) {
                         name += ":";
                         if (wantHtml) {
-                            name += '' + typeObj.bitOffsetInHost + '';
+                            name += '' + ptrObj.bitOffsetInHost + '';
                         } else {
-                            name += typeObj.bitOffsetInHost;
+                            name += ptrObj.bitOffsetInHost;
                         }
                         name += ":";
                         if (wantHtml) {
-                            name += '' + typeObj.hostIntBytes + '';
+                            name += '' + ptrObj.hostIntBytes + '';
                         } else {
-                            name += typeObj.hostIntBytes;
+                            name += ptrObj.hostIntBytes;
                         }
                     }
                     name += ") ";
                 }
-                name += typeValueName(typeObj.child, wantHtml, wantSubLink, null);
+                name += typeValueName(ptrObj.child, wantHtml, wantSubLink, null);
                 return name;
+            }
             case typeKinds.Float:
+            {
+                let floatObj = /** @type {NumberType} */ (typeObj);
+
                 if (wantHtml) {
-                    return 'f' + typeObj.bits + '';
+                    return '' + floatObj.name + '';
                 } else {
-                    return "f" + typeObj.bits;
+                    return floatObj.name;
                 }
+            }
             case typeKinds.Int:
-                var name = typeObj.name;
+            {
+                let intObj = /** @type {NumberType} */(typeObj);
+                var name = intObj.name;
                 if (wantHtml) {
                     return '' + name + '';
                 } else {
                     return name;
                 }
+            }
             case typeKinds.ComptimeInt:
                 if (wantHtml) {
                     return 'comptime_int';
@@ -1160,29 +1267,41 @@ var zigAnalysis;
                     return "noreturn";
                 }
             case typeKinds.ErrorSet:
-                if (typeObj.errors == null) {
+            {
+                let errSetObj = /** @type {ErrSetType} */(typeObj);
+                if (errSetObj.fields == null) {
                     if (wantHtml) {
                         return 'anyerror';
                     } else {
                         return "anyerror";
                     }
                 } else {
-                    if (wantHtml) {
-                        return escapeHtml(typeObj.name);
-                    } else {
-                        return typeObj.name;
-                    }
+                    throw "TODO";
+                    // if (wantHtml) {
+                    //     return escapeHtml(typeObj.name);
+                    // } else {
+                    //     return typeObj.name;
+                    // }
                 }
+            }
             case typeKinds.ErrorUnion:
-                var errSetTypeObj = zigAnalysis.types[typeObj.err];
-                var payloadHtml = typeIndexName(typeObj.payload, wantHtml, wantSubLink, null);
-                if (fnDecl != null && errSetTypeObj.fn === fnDecl.value) {
-                    // function index parameter supplied and this is the inferred error set of it
-                    return "!" + payloadHtml;
-                } else {
-                    return typeIndexName(typeObj.err, wantHtml, wantSubLink, null) + "!" + payloadHtml;
-                }
+            {
+                throw "TODO";
+                // TODO: implement error union printing assuming that both
+                // payload and error union are walk results!
+                // let errUnionObj = /** @type {ErrUnionType} */(typeObj);
+                // var errSetTypeObj = /** @type {ErrSetType} */ (zigAnalysis.types[errUnionObj.err]);
+                // var payloadHtml = typeValueName(errUnionObj.payload, wantHtml, wantSubLink, null);
+                // if (fnDecl != null && errSetTypeObj.fn === fnDecl.value.type) {
+                //     // function index parameter supplied and this is the inferred error set of it
+                //     return "!" + payloadHtml;
+                // } else {
+                //     return typeValueName(errUnionObj.err, wantHtml, wantSubLink, null) + "!" + payloadHtml;
+                // }
+            }
             case typeKinds.Fn:
+            {
+                let fnObj = /** @type {Fn} */(typeObj);
                 var payloadHtml = "";
                 if (wantHtml) {
                     payloadHtml += 'fn';
@@ -1200,19 +1319,19 @@ var zigAnalysis;
                     payloadHtml += 'fn'
                 }
                 payloadHtml += '(';
-                    if (typeObj.params) {
+                    if (fnObj.params) {
                         var fields = null;
                         var isVarArgs = false;
-                        var fnNode = zigAnalysis.astNodes[typeObj.src];
+                        var fnNode = zigAnalysis.astNodes[fnObj.src];
                         fields = fnNode.fields;
                         isVarArgs = fnNode.varArgs;
 
-                        for (var i = 0; i < typeObj.params.length; i += 1) {
+                        for (var i = 0; i < fnObj.params.length; i += 1) {
                             if (i != 0) {
                                 payloadHtml += ', ';
                             }
 
-                            var value = typeObj.params[i];
+                            var value = fnObj.params[i];
                             var paramValue = resolveValue(value);
                             var isCte = "comptimeExpr" in paramValue;
 
@@ -1249,7 +1368,7 @@ var zigAnalysis;
                                 }
                             }
 
-                            if (isVarArgs && i === typeObj.params.length - 1) {
+                            if (isVarArgs && i === fnObj.params.length - 1) {
                                 payloadHtml += '...';
                             } else if ("refPath" in value) {
                                 payloadHtml += '';
@@ -1257,7 +1376,7 @@ var zigAnalysis;
                                 payloadHtml += '';
 
                             } else if ("type" in value) {
-                                var name = typeValueName(value, false);
+                                var name = typeValueName(value, wantHtml, wantSubLink, fnDecl, linkFnNameDecl);
                                 payloadHtml += '' + escapeHtml(name) + '';
                             } else if ("comptimeExpr" in value) {
                                 payloadHtml += '[ComptimeExpr]';
@@ -1270,23 +1389,26 @@ var zigAnalysis;
                     }
 
                 payloadHtml += ') ';
-                if (typeObj.ret != null) {
-                    payloadHtml += typeValueName(typeObj.ret, wantHtml, wantSubLink, fnDecl);
+                if (fnObj.ret != null) {
+                    payloadHtml += typeValueName(fnObj.ret, wantHtml, wantSubLink, fnDecl);
                 } else if (wantHtml) {
                     payloadHtml += 'anytype';
                 } else {
                     payloadHtml += 'anytype';
                 }
                 return payloadHtml;
+            }
             default:
-                if (wantHtml) {
-                    return escapeHtml(typeObj.name);
-                } else {
-                    return typeObj.name;
-                }
+                throw "TODO";
+                // if (wantHtml) {
+                //     return escapeHtml(typeObj.name);
+                // } else {
+                //     return typeObj.name;
+                // }
         }
     }
 
+    /** @param {Type} typeObj */
     function renderType(typeObj) {
         var name;
         if (rootIsStd && typeObj === zigAnalysis.types[zigAnalysis.packages[zigAnalysis.rootPkg].main]) {
@@ -1299,32 +1421,30 @@ var zigAnalysis;
             domHdrName.classList.remove("hidden");
         }
         if (typeObj.kind == typeKinds.ErrorSet) {
-            renderErrorSet(typeObj);
+            renderErrorSet(/** @type {ErrSetType} */(typeObj));
         }
     }
 
+    /** @param {ErrSetType} errSetType */
     function renderErrorSet(errSetType) {
-        if (errSetType.errors == null) {
+        if (errSetType.fields == null) {
             domFnErrorsAnyError.classList.remove("hidden");
         } else {
             var errorList = [];
-            for (var i = 0; i < errSetType.errors.length; i += 1) {
-                var errObj = zigAnalysis.errors[errSetType.errors[i]];
-                var srcObj = zigAnalysis.astNodes[errObj.src];
-                errorList.push({
-                    err: errObj,
-                    docs: srcObj.docs,
-                });
+            for (var i = 0; i < errSetType.fields.length; i += 1) {
+                var errObj = errSetType.fields[i];
+                //var srcObj = zigAnalysis.astNodes[errObj.src];
+                errorList.push(errObj);
             }
             errorList.sort(function(a, b) {
-                return operatorCompare(a.err.name.toLowerCase(), b.err.name.toLowerCase());
+                return operatorCompare(a.name.toLowerCase(), b.name.toLowerCase());
             });
 
             resizeDomListDl(domListFnErrors, errorList.length);
             for (var i = 0; i < errorList.length; i += 1) {
                 var nameTdDom = domListFnErrors.children[i * 2 + 0];
                 var descTdDom = domListFnErrors.children[i * 2 + 1];
-                nameTdDom.textContent = errorList[i].err.name;
+                nameTdDom.textContent = errorList[i].name;
                 var docs = errorList[i].docs;
                 if (docs != null) {
                     descTdDom.innerHTML = markdown(docs);
@@ -1517,7 +1637,7 @@ var zigAnalysis;
                     let fDecl = resolveValue(c.func);
                     if ("type" in fDecl) {
                         console.assert("type" in fDecl);
-                        let fType = zigAnalysis.types[fDecl.type];
+                        let fType = /** @type {Fn} */(zigAnalysis.types[fDecl.type]);
                         console.assert("type" in fType.ret);
                         if (fType.ret.type === typeTypeId) {
                             typesList.push(decl);
@@ -1671,7 +1791,7 @@ var zigAnalysis;
                 } else {
                     var field = container.fields[i];
                     html += ": ";
-                    var name = typeValueName(field);
+                    var name = typeValueName(field, false, false);
                     html += ''+ name +'';
                 }
 
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 913851154c..206728a7b0 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -409,6 +409,7 @@ const DocData = struct {
         ErrorSet: struct {
             name: []const u8,
             fields: []const Field,
+            // TODO: fn field for inferred error sets?
         },
         Enum: struct {
             name: []const u8,

From 67da1b8c88ffbb846e56802a6a1bc187714bbed2 Mon Sep 17 00:00:00 2001
From: Loris Cro 
Date: Sun, 3 Apr 2022 17:57:15 +0200
Subject: [PATCH 048/137] autodoc: fixed all type errors in main.js

---
 lib/docs/main.js | 100 +++++++++++++++++++++++++++++------------------
 1 file changed, 63 insertions(+), 37 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 1335bcce2d..8e9f1e56b0 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -73,7 +73,8 @@
       name: string,
       src: number,
       ret: WalkResult,
-      params: WalkResult[]
+      params: WalkResult[],
+      generic: boolean,
  }} Fn
 */
 
@@ -189,18 +190,15 @@
 
 /**
  * @typedef {{
-      name: string,
-      src?: number,
-      privDecls: number[],
-      pubDecls: number[],
-      fields?: WalkResult[],
+     typeRef: WalkResult,
+     fieldVals: WalkResult[],
    }} Struct
 */
 
 /**
  * @typedef {{
-      len: WalkResult,
-      child: WalkResult,
+      typeRef: WalkResult,
+      data: WalkResult[],
   }} ZigArray
 */
 
@@ -280,7 +278,7 @@ var zigAnalysis;
     var domSectSearchNoResults = /** @type HTMLElement */(document.getElementById("sectSearchNoResults"));
     var domSectInfo = /** @type HTMLElement */(document.getElementById("sectInfo"));
     var domTdTarget = /** @type HTMLElement */(document.getElementById("tdTarget"));
-    var domPrivDeclsBox = /** @type HTMLCheckboxElement */(document.getElementById("privDeclsBox"));
+    var domPrivDeclsBox = /** @type HTMLInputElement */(document.getElementById("privDeclsBox"));
     var domTdZigVer = /** @type HTMLElement */(document.getElementById("tdZigVer"));
     var domHdrName = /** @type HTMLElement */(document.getElementById("hdrName"));
     var domHelpModal = /** @type HTMLElement */(document.getElementById("helpDialog"));
@@ -313,7 +311,7 @@ var zigAnalysis;
     *       pkgNames: string[],
     *       pkgObjs: Package[],
     *       declNames: string[],
-    *       declObjs: Decl[],
+    *       declObjs: (Decl | Type)[],
     *       callName: any,
     *   }} CurNav
     */
@@ -378,53 +376,68 @@ var zigAnalysis;
         }
     }
 
+    /** @param {Type | Decl} x */
     function isDecl(x) {
         return "value" in x;
     }
 
+    /** @param {Type | Decl} x */
     function isType(x) {
         return "kind" in x && !("value" in x);
     }
 
+    /** @param {Type | Decl} x */
     function isContainerType(x) {
-        return isType(x) && typeKindIsContainer(x.kind) ;
+        return isType(x) && typeKindIsContainer(/** @type {Type} */(x).kind) ;
     }
 
+    /** @param {Type} type */
     function typeShorthandName(type) {
-        var name = type.name;
+        var name = undefined;
         if (type.kind === typeKinds.Struct) {
             name = "struct";
         } else if (type.kind === typeKinds.Enum) {
             name = "enum";
         } else if (type.kind === typeKinds.Union) {
-            name= "union";
+            name = "union";
+        } else {
+            name = /** @type {any} */(type).name;
         }
-
         return escapeHtml(name);
     }
 
+    /** @param {number} typeKind */
     function typeKindIsContainer(typeKind) {
         return typeKind === typeKinds.Struct ||
             typeKind === typeKinds.Union ||
             typeKind === typeKinds.Enum;
     }
 
+    /** @param {number} typeKind */
     function declCanRepresentTypeKind(typeKind) {
         return typeKind === typeKinds.ErrorSet || typeKindIsContainer(typeKind);
     }
 
+    /**
+        * @param {WalkResult[]} path
+        * @return {WalkResult | null}
+    */
     function findCteInRefPath(path) {
         for (var i = path.length - 1; i >= 0; i -= 1) {
             const ref = path[i];
             if ("string" in ref) continue;
             if ("comptimeExpr" in ref) return ref;
-            if ("refPath" in ref) return findCteinRefPath(ref.refPath);
+            if ("refPath" in ref) return findCteInRefPath(ref.refPath);
             return null;
         }
 
         return null;
     }
 
+    /**
+        * @param {WalkResult} value
+        * @return {WalkResult}
+    */
     function resolveValue(value) {
         var i = 0;
         while(i < 1000) {
@@ -444,21 +457,26 @@ var zigAnalysis;
 
         }
         console.assert(false);
+        return /** @type {WalkResult} */({});
     }
 
+    /**
+        * @param {Decl} decl
+        * @return {WalkResult}
+    */
     function typeOfDecl(decl){
         var i = 0;
         while(i < 1000) {
             i += 1;
             console.assert(isDecl(decl));
             if ("type" in decl.value) {
-                return { type: typeTypeId };
+                return /** @type {WalkResult} */({ type: typeTypeId });
             }
 
             if ("refPath" in decl.value) {
-                decl =  {
+                decl =  /** @type {Decl} */({
                   value: decl.value.refPath[decl.value.refPath.length -1]
-                };
+                });
                 continue;
             }
 
@@ -495,22 +513,22 @@ var zigAnalysis;
                     fn_decl = zigAnalysis.decls[fn_call.func.declRef];
                 } else if ("refPath" in fn_call.func) {
                     console.assert("declRef" in fn_call.func.refPath[fn_call.func.refPath.length -1]);
-                    fn_decl = zigAnalysis.decls[fn_call.func.refPath[fn_call.func.refPath.length -1].declRef.value];
+                    fn_decl = zigAnalysis.decls[fn_call.func.refPath[fn_call.func.refPath.length -1].declRef];
                 } else throw {};
 
                 const fn_decl_value = resolveValue(fn_decl.value);
                 console.assert("type" in fn_decl_value); //TODO handle comptimeExpr
-                const fn_type = zigAnalysis.types[fn_decl_value.type];
+                const fn_type = /** @type {Fn} */(zigAnalysis.types[fn_decl_value.type]);
                 console.assert(fn_type.kind === typeKinds.Fn);
                 return fn_type.ret;
             }
 
             if ("void" in decl.value) {
-                return { type: typeTypeId };
+                return /** @type {WalkResult} */({ type: typeTypeId });
             }
 
             if ("bool" in decl.value) {
-                return { type: typeKinds.Bool };
+                return /** @type {WalkResult} */({ type: typeKinds.Bool });
             }
 
             console.log("TODO: handle in `typeOfDecl` more cases: ", decl);
@@ -518,6 +536,7 @@ var zigAnalysis;
             throw {};
         }
         console.assert(false);
+        return /** @type {WalkResult} */({});
     }
 
     function render() {
@@ -569,15 +588,18 @@ var zigAnalysis;
             curNav.pkgObjs.push(pkg);
         }
 
+        /** @type {Decl | Type} */
         var currentType = zigAnalysis.types[pkg.main];
         curNav.declObjs = [currentType];
         for (var i = 0; i < curNav.declNames.length; i += 1) {
-            var childDecl = findSubDecl(currentType, curNav.declNames[i]);
+
+            /** @type {Decl | Type | null} */
+            var childDecl = findSubDecl(/** @type {ContainerType} */(currentType), curNav.declNames[i]);
             if (childDecl == null) {
                 return render404();
             }
 
-            var childDeclValue = resolveValue(childDecl.value);
+            var childDeclValue = resolveValue(/** @type {Decl} */(childDecl).value);
             if ("type" in childDeclValue) {
 
                 const t = zigAnalysis.types[childDeclValue.type];
@@ -586,7 +608,7 @@ var zigAnalysis;
                 }
             }
 
-            currentType = childDecl;
+            currentType = /** @type {Decl | Type} */(childDecl);
             curNav.declObjs.push(currentType);
         }
 
@@ -598,31 +620,32 @@ var zigAnalysis;
         var lastIsContainerType = isContainerType(last);
 
         if (lastIsContainerType) {
-            return renderContainer(last);
+            return renderContainer(/** @type {ContainerType} */(last));
         }
 
         if (!lastIsDecl && !lastIsType) {
-            return renderUnknownDecl(last);
+            return renderUnknownDecl(/** @type {Decl} */(last));
         }
 
         if (lastIsType) {
-            return renderType(last);
+            return renderType(/** @type {Type} */(last));
         }
 
         if (lastIsDecl && last.kind === 'var') {
-            return renderVar(last);
+            return renderVar(/** @type {Decl} */(last));
         }
 
         if (lastIsDecl && last.kind === 'const') {
-            var typeObj = zigAnalysis.types[resolveValue(last.value).type];
+            var typeObj = zigAnalysis.types[resolveValue(/** @type {Decl} */(last).value).type];
             if (typeObj && typeObj.kind === typeKinds.Fn) {
-                return renderFn(last);
+                return renderFn(/** @type {Decl} */(last));
             }
 
-            return renderValue(last);
+            return renderValue(/** @type {Decl} */(last));
         }
     }
 
+    /** @param {Decl} decl */
     function renderUnknownDecl(decl) {
         domDeclNoRef.classList.remove("hidden");
 
@@ -635,31 +658,34 @@ var zigAnalysis;
         domTldDocs.classList.remove("hidden");
     }
 
+    /** @param {number} typeIndex */
     function typeIsErrSet(typeIndex) {
         var typeObj = zigAnalysis.types[typeIndex];
         return typeObj.kind === typeKinds.ErrorSet;
     }
 
+    /** @param {number} typeIndex */
     function typeIsStructWithNoFields(typeIndex) {
         var typeObj = zigAnalysis.types[typeIndex];
         if (typeObj.kind !== typeKinds.Struct)
             return false;
-        return typeObj.fields.length == 0;
+        return /** @type {ContainerType} */(typeObj).fields.length == 0;
     }
 
+    /** @param {number} typeIndex */
     function typeIsGenericFn(typeIndex) {
         var typeObj = zigAnalysis.types[typeIndex];
         if (typeObj.kind !== typeKinds.Fn) {
             return false;
         }
-        return typeObj.generic;
+        return  /** @type {Fn} */(typeObj).generic;
     }
 
     /** @param {Decl} fnDecl */
     function renderFn(fnDecl) {
         var value = resolveValue(fnDecl.value);
         console.assert("type" in value);
-        var typeObj = zigAnalysis.types[value.type];
+        var typeObj = /** @type {Fn} */(zigAnalysis.types[value.type]);
 
         domFnProtoCode.innerHTML = typeValueName(value, true, true, fnDecl);
 
@@ -672,12 +698,12 @@ var zigAnalysis;
         var retIndex = resolveValue(typeObj.ret).type;
         renderFnParamDocs(fnDecl, typeObj);
 
-        var errSetTypeIndex = null;
+        var errSetTypeIndex = /** @type {number | null} */(null);
         var retType = zigAnalysis.types[retIndex];
         if (retType.kind === typeKinds.ErrorSet) {
             errSetTypeIndex = retIndex;
         } else if (retType.kind === typeKinds.ErrorUnion) {
-            errSetTypeIndex = retType.err;
+            errSetTypeIndex = /** @type {ErrUnionType} */(retType).err.type;
         }
         if (errSetTypeIndex != null) {
             var errSetType = /** @type {ErrSetType} */(zigAnalysis.types[errSetTypeIndex]);

From d85259989e7c8f0f28fa80dc7970792b6411e1ed Mon Sep 17 00:00:00 2001
From: Loris Cro 
Date: Sun, 3 Apr 2022 18:06:31 +0200
Subject: [PATCH 049/137] autodoc: var 2 let in main.js

---
 lib/docs/main.js | 732 +++++++++++++++++++++++------------------------
 1 file changed, 366 insertions(+), 366 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 8e9f1e56b0..f7a434ae06 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -236,75 +236,75 @@
 var zigAnalysis;
 
 (function() {
-    var domStatus = /** @type HTMLElement */(document.getElementById("status"));
-    var domSectNav = /** @type HTMLElement */(document.getElementById("sectNav"));
-    var domListNav = /** @type HTMLElement */(document.getElementById("listNav"));
-    var domSectMainPkg = /** @type HTMLElement */(document.getElementById("sectMainPkg"));
-    var domSectPkgs = /** @type HTMLElement */(document.getElementById("sectPkgs"));
-    var domListPkgs = /** @type HTMLElement */(document.getElementById("listPkgs"));
-    var domSectTypes = /** @type HTMLElement */(document.getElementById("sectTypes"));
-    var domListTypes = /** @type HTMLElement */(document.getElementById("listTypes"));
-    var domSectTests = /** @type HTMLElement */(document.getElementById("sectTests"));
-    var domListTests = /** @type HTMLElement */(document.getElementById("listTests"));
-    var domSectNamespaces = /** @type HTMLElement */(document.getElementById("sectNamespaces"));
-    var domListNamespaces = /** @type HTMLElement */(document.getElementById("listNamespaces"));
-    var domSectErrSets = /** @type HTMLElement */(document.getElementById("sectErrSets"));
-    var domListErrSets = /** @type HTMLElement */(document.getElementById("listErrSets"));
-    var domSectFns = /** @type HTMLElement */(document.getElementById("sectFns"));
-    var domListFns = /** @type HTMLElement */(document.getElementById("listFns"));
-    var domSectFields = /** @type HTMLElement */(document.getElementById("sectFields"));
-    var domListFields = /** @type HTMLElement */(document.getElementById("listFields"));
-    var domSectGlobalVars = /** @type HTMLElement */(document.getElementById("sectGlobalVars"));
-    var domListGlobalVars = /** @type HTMLElement */(document.getElementById("listGlobalVars"));
-    var domSectValues = /** @type HTMLElement */(document.getElementById("sectValues"));
-    var domListValues = /** @type HTMLElement */(document.getElementById("listValues"));
-    var domFnProto = /** @type HTMLElement */(document.getElementById("fnProto"));
-    var domFnProtoCode = /** @type HTMLElement */(document.getElementById("fnProtoCode"));
-    var domSectParams = /** @type HTMLElement */(document.getElementById("sectParams"));
-    var domListParams = /** @type HTMLElement */(document.getElementById("listParams"));
-    var domTldDocs = /** @type HTMLElement */(document.getElementById("tldDocs"));
-    var domSectFnErrors = /** @type HTMLElement */(document.getElementById("sectFnErrors"));
-    var domListFnErrors = /** @type HTMLElement */(document.getElementById("listFnErrors"));
-    var domTableFnErrors =/** @type HTMLElement */(document.getElementById("tableFnErrors"));
-    var domFnErrorsAnyError = /** @type HTMLElement */(document.getElementById("fnErrorsAnyError"));
-    var domFnExamples = /** @type HTMLElement */(document.getElementById("fnExamples"));
-    var domListFnExamples = /** @type HTMLElement */(document.getElementById("listFnExamples"));
-    var domFnNoExamples = /** @type HTMLElement */(document.getElementById("fnNoExamples"));
-    var domDeclNoRef = /** @type HTMLElement */(document.getElementById("declNoRef"));
-    var domSearch = /** @type HTMLInputElement */(document.getElementById("search"));
-    var domSectSearchResults = /** @type HTMLElement */(document.getElementById("sectSearchResults"));
+    let domStatus = /** @type HTMLElement */(document.getElementById("status"));
+    let domSectNav = /** @type HTMLElement */(document.getElementById("sectNav"));
+    let domListNav = /** @type HTMLElement */(document.getElementById("listNav"));
+    let domSectMainPkg = /** @type HTMLElement */(document.getElementById("sectMainPkg"));
+    let domSectPkgs = /** @type HTMLElement */(document.getElementById("sectPkgs"));
+    let domListPkgs = /** @type HTMLElement */(document.getElementById("listPkgs"));
+    let domSectTypes = /** @type HTMLElement */(document.getElementById("sectTypes"));
+    let domListTypes = /** @type HTMLElement */(document.getElementById("listTypes"));
+    let domSectTests = /** @type HTMLElement */(document.getElementById("sectTests"));
+    let domListTests = /** @type HTMLElement */(document.getElementById("listTests"));
+    let domSectNamespaces = /** @type HTMLElement */(document.getElementById("sectNamespaces"));
+    let domListNamespaces = /** @type HTMLElement */(document.getElementById("listNamespaces"));
+    let domSectErrSets = /** @type HTMLElement */(document.getElementById("sectErrSets"));
+    let domListErrSets = /** @type HTMLElement */(document.getElementById("listErrSets"));
+    let domSectFns = /** @type HTMLElement */(document.getElementById("sectFns"));
+    let domListFns = /** @type HTMLElement */(document.getElementById("listFns"));
+    let domSectFields = /** @type HTMLElement */(document.getElementById("sectFields"));
+    let domListFields = /** @type HTMLElement */(document.getElementById("listFields"));
+    let domSectGlobalVars = /** @type HTMLElement */(document.getElementById("sectGlobalVars"));
+    let domListGlobalVars = /** @type HTMLElement */(document.getElementById("listGlobalVars"));
+    let domSectValues = /** @type HTMLElement */(document.getElementById("sectValues"));
+    let domListValues = /** @type HTMLElement */(document.getElementById("listValues"));
+    let domFnProto = /** @type HTMLElement */(document.getElementById("fnProto"));
+    let domFnProtoCode = /** @type HTMLElement */(document.getElementById("fnProtoCode"));
+    let domSectParams = /** @type HTMLElement */(document.getElementById("sectParams"));
+    let domListParams = /** @type HTMLElement */(document.getElementById("listParams"));
+    let domTldDocs = /** @type HTMLElement */(document.getElementById("tldDocs"));
+    let domSectFnErrors = /** @type HTMLElement */(document.getElementById("sectFnErrors"));
+    let domListFnErrors = /** @type HTMLElement */(document.getElementById("listFnErrors"));
+    let domTableFnErrors =/** @type HTMLElement */(document.getElementById("tableFnErrors"));
+    let domFnErrorsAnyError = /** @type HTMLElement */(document.getElementById("fnErrorsAnyError"));
+    let domFnExamples = /** @type HTMLElement */(document.getElementById("fnExamples"));
+    let domListFnExamples = /** @type HTMLElement */(document.getElementById("listFnExamples"));
+    let domFnNoExamples = /** @type HTMLElement */(document.getElementById("fnNoExamples"));
+    let domDeclNoRef = /** @type HTMLElement */(document.getElementById("declNoRef"));
+    let domSearch = /** @type HTMLInputElement */(document.getElementById("search"));
+    let domSectSearchResults = /** @type HTMLElement */(document.getElementById("sectSearchResults"));
 
-    var domListSearchResults = /** @type HTMLElement */(document.getElementById("listSearchResults"));
-    var domSectSearchNoResults = /** @type HTMLElement */(document.getElementById("sectSearchNoResults"));
-    var domSectInfo = /** @type HTMLElement */(document.getElementById("sectInfo"));
-    var domTdTarget = /** @type HTMLElement */(document.getElementById("tdTarget"));
-    var domPrivDeclsBox = /** @type HTMLInputElement */(document.getElementById("privDeclsBox"));
-    var domTdZigVer = /** @type HTMLElement */(document.getElementById("tdZigVer"));
-    var domHdrName = /** @type HTMLElement */(document.getElementById("hdrName"));
-    var domHelpModal = /** @type HTMLElement */(document.getElementById("helpDialog"));
+    let domListSearchResults = /** @type HTMLElement */(document.getElementById("listSearchResults"));
+    let domSectSearchNoResults = /** @type HTMLElement */(document.getElementById("sectSearchNoResults"));
+    let domSectInfo = /** @type HTMLElement */(document.getElementById("sectInfo"));
+    let domTdTarget = /** @type HTMLElement */(document.getElementById("tdTarget"));
+    let domPrivDeclsBox = /** @type HTMLInputElement */(document.getElementById("privDeclsBox"));
+    let domTdZigVer = /** @type HTMLElement */(document.getElementById("tdZigVer"));
+    let domHdrName = /** @type HTMLElement */(document.getElementById("hdrName"));
+    let domHelpModal = /** @type HTMLElement */(document.getElementById("helpDialog"));
 
     /** @type number | null */
-    var searchTimer = null;
+    let searchTimer = null;
 
     /** @type Object */
-    var escapeHtmlReplacements = { "&": "&", '"': """, "<": "<", ">": ">" };
+    let escapeHtmlReplacements = { "&": "&", '"': """, "<": "<", ">": ">" };
 
-    var typeKinds = /** @type {Record} */(indexTypeKinds());
-    var typeTypeId = /** @type {number} */ (findTypeTypeId());
-    var pointerSizeEnum = { One: 0, Many: 1, Slice: 2, C: 3 };
+    let typeKinds = /** @type {Record} */(indexTypeKinds());
+    let typeTypeId = /** @type {number} */ (findTypeTypeId());
+    let pointerSizeEnum = { One: 0, Many: 1, Slice: 2, C: 3 };
 
     // for each package, is an array with packages to get to this one
-    var canonPkgPaths = computeCanonicalPackagePaths();
+    let canonPkgPaths = computeCanonicalPackagePaths();
 
     /** @typedef {{declNames: string[], pkgNames: string[]}} CanonDecl */
 
     // for each decl, is an array with {declNames, pkgNames} to get to this one
     /** @type CanonDecl[] | null */
-    var canonDeclPaths = null; // lazy; use getCanonDeclPath
+    let canonDeclPaths = null; // lazy; use getCanonDeclPath
 
     // for each type, is an array with {declNames, pkgNames} to get to this one
     /** @type  number[] | null */
-    var canonTypeDecls = null; // lazy; use getCanonTypeDecl
+    let canonTypeDecls = null; // lazy; use getCanonTypeDecl
 
     /** @typedef {{
     *       showPrivDecls: boolean,
@@ -317,7 +317,7 @@ var zigAnalysis;
     */
 
     /** @type {CurNav} */
-    var curNav = {
+    let curNav = {
         showPrivDecls: false,
         // each element is a package name, e.g. @import("a") then within there @import("b")
         // starting implicitly from root package
@@ -334,16 +334,16 @@ var zigAnalysis;
         callName: null,
     };
 
-    var curNavSearch = "";
-    var curSearchIndex = -1;
-    var imFeelingLucky = false;
+    let curNavSearch = "";
+    let curSearchIndex = -1;
+    let imFeelingLucky = false;
 
-    var rootIsStd = detectRootIsStd();
+    let rootIsStd = detectRootIsStd();
 
     // map of decl index to list of non-generic fn indexes
-    // var nodesToFnsMap = indexNodesToFns();
+    // let nodesToFnsMap = indexNodesToFns();
     // map of decl index to list of comptime fn calls
-    // var nodesToCallsMap = indexNodesToCalls();
+    // let nodesToCallsMap = indexNodesToCalls();
 
     domSearch.addEventListener('keydown', onSearchKeyDown, false);
     domPrivDeclsBox.addEventListener('change', function() {
@@ -363,8 +363,8 @@ var zigAnalysis;
     onHashChange();
 
     function renderTitle() {
-        var list = curNav.pkgNames.concat(curNav.declNames);
-        var suffix = " - Zig";
+        let list = curNav.pkgNames.concat(curNav.declNames);
+        let suffix = " - Zig";
         if (list.length === 0) {
             if (rootIsStd) {
                 document.title = "std" + suffix;
@@ -393,7 +393,7 @@ var zigAnalysis;
 
     /** @param {Type} type */
     function typeShorthandName(type) {
-        var name = undefined;
+        let name = undefined;
         if (type.kind === typeKinds.Struct) {
             name = "struct";
         } else if (type.kind === typeKinds.Enum) {
@@ -423,7 +423,7 @@ var zigAnalysis;
         * @return {WalkResult | null}
     */
     function findCteInRefPath(path) {
-        for (var i = path.length - 1; i >= 0; i -= 1) {
+        for (let i = path.length - 1; i >= 0; i -= 1) {
             const ref = path[i];
             if ("string" in ref) continue;
             if ("comptimeExpr" in ref) return ref;
@@ -439,7 +439,7 @@ var zigAnalysis;
         * @return {WalkResult}
     */
     function resolveValue(value) {
-        var i = 0;
+        let i = 0;
         while(i < 1000) {
             i += 1;
 
@@ -465,7 +465,7 @@ var zigAnalysis;
         * @return {WalkResult}
     */
     function typeOfDecl(decl){
-        var i = 0;
+        let i = 0;
         while(i < 1000) {
             i += 1;
             console.assert(isDecl(decl));
@@ -508,7 +508,7 @@ var zigAnalysis;
 
             if ("call" in decl.value) {
                 const fn_call = zigAnalysis.calls[decl.value.call];
-                var fn_decl = undefined;
+                let fn_decl = undefined;
                 if ("declRef" in fn_call.func) {
                     fn_decl = zigAnalysis.decls[fn_call.func.declRef];
                 } else if ("refPath" in fn_call.func) {
@@ -576,11 +576,11 @@ var zigAnalysis;
             return renderSearch();
         }
 
-        var rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
-        var pkg = rootPkg;
+        let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
+        let pkg = rootPkg;
         curNav.pkgObjs = [pkg];
-        for (var i = 0; i < curNav.pkgNames.length; i += 1) {
-            var childPkg = zigAnalysis.packages[pkg.table[curNav.pkgNames[i]]];
+        for (let i = 0; i < curNav.pkgNames.length; i += 1) {
+            let childPkg = zigAnalysis.packages[pkg.table[curNav.pkgNames[i]]];
             if (childPkg == null) {
                 return render404();
             }
@@ -589,17 +589,17 @@ var zigAnalysis;
         }
 
         /** @type {Decl | Type} */
-        var currentType = zigAnalysis.types[pkg.main];
+        let currentType = zigAnalysis.types[pkg.main];
         curNav.declObjs = [currentType];
-        for (var i = 0; i < curNav.declNames.length; i += 1) {
+        for (let i = 0; i < curNav.declNames.length; i += 1) {
 
             /** @type {Decl | Type | null} */
-            var childDecl = findSubDecl(/** @type {ContainerType} */(currentType), curNav.declNames[i]);
+            let childDecl = findSubDecl(/** @type {ContainerType} */(currentType), curNav.declNames[i]);
             if (childDecl == null) {
                 return render404();
             }
 
-            var childDeclValue = resolveValue(/** @type {Decl} */(childDecl).value);
+            let childDeclValue = resolveValue(/** @type {Decl} */(childDecl).value);
             if ("type" in childDeclValue) {
 
                 const t = zigAnalysis.types[childDeclValue.type];
@@ -614,10 +614,10 @@ var zigAnalysis;
 
         renderNav();
 
-        var last = curNav.declObjs[curNav.declObjs.length - 1];
-        var lastIsDecl = isDecl(last);
-        var lastIsType = isType(last);
-        var lastIsContainerType = isContainerType(last);
+        let last = curNav.declObjs[curNav.declObjs.length - 1];
+        let lastIsDecl = isDecl(last);
+        let lastIsType = isType(last);
+        let lastIsContainerType = isContainerType(last);
 
         if (lastIsContainerType) {
             return renderContainer(/** @type {ContainerType} */(last));
@@ -636,7 +636,7 @@ var zigAnalysis;
         }
 
         if (lastIsDecl && last.kind === 'const') {
-            var typeObj = zigAnalysis.types[resolveValue(/** @type {Decl} */(last).value).type];
+            let typeObj = zigAnalysis.types[resolveValue(/** @type {Decl} */(last).value).type];
             if (typeObj && typeObj.kind === typeKinds.Fn) {
                 return renderFn(/** @type {Decl} */(last));
             }
@@ -649,7 +649,7 @@ var zigAnalysis;
     function renderUnknownDecl(decl) {
         domDeclNoRef.classList.remove("hidden");
 
-        var docs = zigAnalysis.astNodes[decl.src].docs;
+        let docs = zigAnalysis.astNodes[decl.src].docs;
         if (docs != null) {
             domTldDocs.innerHTML = markdown(docs);
         } else {
@@ -660,13 +660,13 @@ var zigAnalysis;
 
     /** @param {number} typeIndex */
     function typeIsErrSet(typeIndex) {
-        var typeObj = zigAnalysis.types[typeIndex];
+        let typeObj = zigAnalysis.types[typeIndex];
         return typeObj.kind === typeKinds.ErrorSet;
     }
 
     /** @param {number} typeIndex */
     function typeIsStructWithNoFields(typeIndex) {
-        var typeObj = zigAnalysis.types[typeIndex];
+        let typeObj = zigAnalysis.types[typeIndex];
         if (typeObj.kind !== typeKinds.Struct)
             return false;
         return /** @type {ContainerType} */(typeObj).fields.length == 0;
@@ -674,7 +674,7 @@ var zigAnalysis;
 
     /** @param {number} typeIndex */
     function typeIsGenericFn(typeIndex) {
-        var typeObj = zigAnalysis.types[typeIndex];
+        let typeObj = zigAnalysis.types[typeIndex];
         if (typeObj.kind !== typeKinds.Fn) {
             return false;
         }
@@ -683,38 +683,38 @@ var zigAnalysis;
 
     /** @param {Decl} fnDecl */
     function renderFn(fnDecl) {
-        var value = resolveValue(fnDecl.value);
+        let value = resolveValue(fnDecl.value);
         console.assert("type" in value);
-        var typeObj = /** @type {Fn} */(zigAnalysis.types[value.type]);
+        let typeObj = /** @type {Fn} */(zigAnalysis.types[value.type]);
 
         domFnProtoCode.innerHTML = typeValueName(value, true, true, fnDecl);
 
-        var docsSource = null;
-        var srcNode = zigAnalysis.astNodes[fnDecl.src];
+        let docsSource = null;
+        let srcNode = zigAnalysis.astNodes[fnDecl.src];
         if (srcNode.docs != null) {
             docsSource = srcNode.docs;
         }
 
-        var retIndex = resolveValue(typeObj.ret).type;
+        let retIndex = resolveValue(typeObj.ret).type;
         renderFnParamDocs(fnDecl, typeObj);
 
-        var errSetTypeIndex = /** @type {number | null} */(null);
-        var retType = zigAnalysis.types[retIndex];
+        let errSetTypeIndex = /** @type {number | null} */(null);
+        let retType = zigAnalysis.types[retIndex];
         if (retType.kind === typeKinds.ErrorSet) {
             errSetTypeIndex = retIndex;
         } else if (retType.kind === typeKinds.ErrorUnion) {
             errSetTypeIndex = /** @type {ErrUnionType} */(retType).err.type;
         }
         if (errSetTypeIndex != null) {
-            var errSetType = /** @type {ErrSetType} */(zigAnalysis.types[errSetTypeIndex]);
+            let errSetType = /** @type {ErrSetType} */(zigAnalysis.types[errSetTypeIndex]);
             renderErrorSet(errSetType);
         }
 
-        var protoSrcIndex = fnDecl.src;
+        let protoSrcIndex = fnDecl.src;
         if (typeIsGenericFn(value.type)) {
             throw "TODO";
-            // var instantiations = nodesToFnsMap[protoSrcIndex];
-            // var calls = nodesToCallsMap[protoSrcIndex];
+            // let instantiations = nodesToFnsMap[protoSrcIndex];
+            // let calls = nodesToCallsMap[protoSrcIndex];
             // if (instantiations == null && calls == null) {
             //     domFnNoExamples.classList.remove("hidden");
             // } else if (calls != null) {
@@ -723,8 +723,8 @@ var zigAnalysis;
 
             //     resizeDomList(domListFnExamples, calls.length, '
  • ');
 
-            //     for (var callI = 0; callI < calls.length; callI += 1) {
-            //         var liDom = domListFnExamples.children[callI];
+            //     for (let callI = 0; callI < calls.length; callI += 1) {
+            //         let liDom = domListFnExamples.children[callI];
             //         liDom.innerHTML = getCallHtml(fnDecl, calls[callI]);
             //     }
 
@@ -738,7 +738,7 @@ var zigAnalysis;
             domFnNoExamples.classList.add("hidden");
         }
 
-        var protoSrcNode = zigAnalysis.astNodes[protoSrcIndex];
+        let protoSrcNode = zigAnalysis.astNodes[protoSrcIndex];
         if (docsSource == null && protoSrcNode != null && protoSrcNode.docs != null) {
             docsSource = protoSrcNode.docs;
         }
@@ -754,15 +754,15 @@ var zigAnalysis;
     * @param {Fn} typeObj
     */
     function renderFnParamDocs(fnDecl, typeObj) {
-        var docCount = 0;
+        let docCount = 0;
 
-        var fnNode = zigAnalysis.astNodes[fnDecl.src];
-        var fields = /** @type {number[]} */(fnNode.fields);
-        var isVarArgs = fnNode.varArgs;
+        let fnNode = zigAnalysis.astNodes[fnDecl.src];
+        let fields = /** @type {number[]} */(fnNode.fields);
+        let isVarArgs = fnNode.varArgs;
 
-        for (var i = 0; i < fields.length; i += 1) {
-            var field = fields[i];
-            var fieldNode = zigAnalysis.astNodes[field];
+        for (let i = 0; i < fields.length; i += 1) {
+            let field = fields[i];
+            let fieldNode = zigAnalysis.astNodes[field];
             if (fieldNode.docs != null) {
                 docCount += 1;
             }
@@ -772,30 +772,30 @@ var zigAnalysis;
         }
 
         resizeDomList(domListParams, docCount, '
    ');
-        var domIndex = 0;
+        let domIndex = 0;
 
-        for (var i = 0; i < fields.length; i += 1) {
-            var field = fields[i];
-            var fieldNode = zigAnalysis.astNodes[field];
+        for (let i = 0; i < fields.length; i += 1) {
+            let field = fields[i];
+            let fieldNode = zigAnalysis.astNodes[field];
             if (fieldNode.docs == null) {
                 continue;
             }
-            var divDom = domListParams.children[domIndex];
+            let divDom = domListParams.children[domIndex];
             domIndex += 1;
 
 
-            var value = typeObj.params[i];
-            var html = '
    ' + escapeHtml(/** @type {string} */(fieldNode.name)) + ": ";
+            let value = typeObj.params[i];
+            let html = '
    ' + escapeHtml(/** @type {string} */(fieldNode.name)) + ": ";
             if (isVarArgs && i === typeObj.params.length - 1) {
                 html += '...';
             } else {
-                var name = typeValueName(value, false, false);
+                let name = typeValueName(value, false, false);
                 html += '' + name + '';
             }
 
             html += ',
    ';
 
-            var docs = fieldNode.docs;
+            let docs = fieldNode.docs;
             if (docs != null) {
                 html += markdown(docs);
             }
@@ -805,19 +805,19 @@ var zigAnalysis;
     }
 
     function renderNav() {
-        var len = curNav.pkgNames.length + curNav.declNames.length;
+        let len = curNav.pkgNames.length + curNav.declNames.length;
         resizeDomList(domListNav, len, '
    • ');
-        var list = [];
-        var hrefPkgNames = [];
-        var hrefDeclNames = /** @type {string[]} */([]);
-        for (var i = 0; i < curNav.pkgNames.length; i += 1) {
+        let list = [];
+        let hrefPkgNames = [];
+        let hrefDeclNames = /** @type {string[]} */([]);
+        for (let i = 0; i < curNav.pkgNames.length; i += 1) {
             hrefPkgNames.push(curNav.pkgNames[i]);
             list.push({
                 name: curNav.pkgNames[i],
                 link: navLink(hrefPkgNames, hrefDeclNames),
             });
         }
-        for (var i = 0; i < curNav.declNames.length; i += 1) {
+        for (let i = 0; i < curNav.declNames.length; i += 1) {
             hrefDeclNames.push(curNav.declNames[i]);
             list.push({
                 name: curNav.declNames[i],
@@ -825,9 +825,9 @@ var zigAnalysis;
             });
         }
 
-        for (var i = 0; i < list.length; i += 1) {
-            var liDom = domListNav.children[i];
-            var aDom = liDom.children[0];
+        for (let i = 0; i < list.length; i += 1) {
+            let liDom = domListNav.children[i];
+            let aDom = liDom.children[0];
             aDom.textContent = list[i].name;
             aDom.setAttribute('href', list[i].link);
             if (i + 1 == list.length) {
@@ -853,10 +853,10 @@ var zigAnalysis;
     }
 
     function renderPkgList() {
-        var rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
-        var list = [];
-        for (var key in rootPkg.table) {
-            var pkgIndex = rootPkg.table[key];
+        let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
+        let list = [];
+        for (let key in rootPkg.table) {
+            let pkgIndex = rootPkg.table[key];
             if (zigAnalysis.packages[pkgIndex] == null) continue;
             list.push({
                 name: key,
@@ -865,7 +865,7 @@ var zigAnalysis;
         }
 
         {
-            var aDom = domSectMainPkg.children[1].children[0].children[0];
+            let aDom = domSectMainPkg.children[1].children[0].children[0];
             aDom.textContent = zigAnalysis.params.rootName;
             aDom.setAttribute('href', navLinkPkg(zigAnalysis.rootPkg));
             if (zigAnalysis.params.rootName === curNav.pkgNames[0]) {
@@ -882,9 +882,9 @@ var zigAnalysis;
 
         if (list.length !== 0) {
             resizeDomList(domListPkgs, list.length, '
    • ');
-            for (var i = 0; i < list.length; i += 1) {
-                var liDom = domListPkgs.children[i];
-                var aDom = liDom.children[0];
+            for (let i = 0; i < list.length; i += 1) {
+                let liDom = domListPkgs.children[i];
+                let aDom = liDom.children[0];
                 aDom.textContent = list[i].name;
                 aDom.setAttribute('href', navLinkPkg(list[i].pkg));
                 if (list[i].name === curNav.pkgNames[0]) {
@@ -933,13 +933,13 @@ var zigAnalysis;
 
     /** @param {Call} callObj */
     function navLinkCall(callObj) {
-        var declNamesCopy = curNav.declNames.concat([]);
-        var callName = /** @type {string} */(declNamesCopy.pop());
+        let declNamesCopy = curNav.declNames.concat([]);
+        let callName = /** @type {string} */(declNamesCopy.pop());
 
         callName += '(';
-            for (var arg_i = 0; arg_i < callObj.args.length; arg_i += 1) {
+            for (let arg_i = 0; arg_i < callObj.args.length; arg_i += 1) {
                 if (arg_i !== 0) callName += ',';
-                var argObj = callObj.args[arg_i];
+                let argObj = callObj.args[arg_i];
                 callName += getValueText(argObj, argObj, false, false);
             }
             callName += ')';
@@ -954,7 +954,7 @@ var zigAnalysis;
     */
     function resizeDomListDl(dlDom, desiredLen) {
         // add the missing dom entries
-        var i, ev;
+        let i, ev;
         for (i = dlDom.childElementCount / 2; i < desiredLen; i += 1) {
             dlDom.insertAdjacentHTML('beforeend', '
    ');
         }
@@ -972,7 +972,7 @@ var zigAnalysis;
     */
     function resizeDomList(listDom, desiredLen, templateHtml) {
         // add the missing dom entries
-        var i, ev;
+        let i, ev;
         for (i = listDom.childElementCount; i < desiredLen; i += 1) {
             listDom.insertAdjacentHTML('beforeend', templateHtml);
         }
@@ -996,11 +996,11 @@ var zigAnalysis;
             return "" + typeValue.int.value;
         }
         if ("call" in typeValue) {
-            var result = "";
-            var call = zigAnalysis.calls[typeValue.call];
-            var functionName = typeValueName(call.func, wantHtml, wantLink, fnDecl, linkFnNameDecl);
+            let result = "";
+            let call = zigAnalysis.calls[typeValue.call];
+            let functionName = typeValueName(call.func, wantHtml, wantLink, fnDecl, linkFnNameDecl);
             result += functionName + "(";
-            for (var j = 0; j < call.args.length; j += 1) {
+            for (let j = 0; j < call.args.length; j += 1) {
               result += typeValueName(call.args[j], wantHtml, wantLink, fnDecl, linkFnNameDecl);
               if (j != call.args.length -1) result += ",";
             }
@@ -1011,10 +1011,10 @@ var zigAnalysis;
             return "[ComptimeExpr]";
         }
         if ("refPath" in typeValue) {
-              var result = "";
-              for (var j = 0; j < typeValue.refPath.length; j++) {
+              let result = "";
+              for (let j = 0; j < typeValue.refPath.length; j++) {
 
-                  var name = "[RefPath]";
+                  let name = "[RefPath]";
                   if (wantHtml) {
                       //result += '';
                       result += '';
@@ -1048,16 +1048,16 @@ var zigAnalysis;
         }
 
         console.assert("type" in typeValue)
-        var typeIndex = typeValue.type;
-        var typeObj = zigAnalysis.types[typeIndex];
-        var declNameOk = declCanRepresentTypeKind(typeObj.kind);
+        let typeIndex = typeValue.type;
+        let typeObj = zigAnalysis.types[typeIndex];
+        let declNameOk = declCanRepresentTypeKind(typeObj.kind);
         if (wantLink) {
-            var declIndex = getCanonTypeDecl(typeIndex);
-            var declPath = getCanonDeclPath(declIndex);
+            let declIndex = getCanonTypeDecl(typeIndex);
+            let declPath = getCanonDeclPath(declIndex);
             if (declPath == null) {
                 return typeName(typeObj, wantHtml, wantLink, fnDecl, linkFnNameDecl);
             }
-            var name = (wantLink && declCanRepresentTypeKind(typeObj.kind)) ?
+            let name = (wantLink && declCanRepresentTypeKind(typeObj.kind)) ?
                 declPath.declNames[declPath.declNames.length - 1] :
                 typeName(typeObj, wantHtml, false, fnDecl, linkFnNameDecl);
             if (wantLink && wantHtml) {
@@ -1075,9 +1075,9 @@ var zigAnalysis;
     * @param {string} paramName
     */
     function shouldSkipParamName(typeRef, paramName) {
-        var resolvedTypeRef = resolveValue(typeRef);
+        let resolvedTypeRef = resolveValue(typeRef);
         if ("type" in resolvedTypeRef) {
-            var typeObj = zigAnalysis.types[resolvedTypeRef.type];
+            let typeObj = zigAnalysis.types[resolvedTypeRef.type];
             if (typeObj.kind === typeKinds.Pointer){
                 let ptrObj = /** @type {PointerType} */(typeObj);
                 if (getPtrSize(ptrObj) === pointerSizeEnum.One) {
@@ -1095,14 +1095,14 @@ var zigAnalysis;
     }
 
     // function getCallHtml(fnDecl, callIndex) {
-    //     var callObj = zigAnalysis.calls[callIndex];
+    //     let callObj = zigAnalysis.calls[callIndex];
 
     //     // TODO make these links work
-    //     //var html = '' + escapeHtml(fnDecl.name) + '(';
-    //         var html = escapeHtml(fnDecl.name) + '(';
-    //             for (var arg_i = 0; arg_i < callObj.args.length; arg_i += 1) {
+    //     //let html = '' + escapeHtml(fnDecl.name) + '(';
+    //         let html = escapeHtml(fnDecl.name) + '(';
+    //             for (let arg_i = 0; arg_i < callObj.args.length; arg_i += 1) {
     //                 if (arg_i !== 0) html += ', ';
-    //                 var argObj = callObj.args[arg_i];
+    //                 let argObj = callObj.args[arg_i];
     //                 html += getValueText(argObj, argObj.value, true, true);
     //             }
     //             html += ')';
@@ -1116,17 +1116,17 @@ var zigAnalysis;
     * @param {boolean} wantLink
     */
     function getValueText(typeRef, value, wantHtml, wantLink) {
-        var resolvedTypeRef = resolveValue(typeRef);
+        let resolvedTypeRef = resolveValue(typeRef);
         if ("comptimeExpr" in resolvedTypeRef) {
             return "[ComptimeExpr]";
         }
         console.assert("type" in resolvedTypeRef);
-        var typeObj = zigAnalysis.types[typeRef.type];
+        let typeObj = zigAnalysis.types[typeRef.type];
         switch (typeObj.kind) {
             case typeKinds.Type:
                 return typeValueName(value, wantHtml, wantLink);
             case typeKinds.Fn:
-                var fnObj = zigAnalysis.fns[value];
+                let fnObj = zigAnalysis.fns[value];
                 return typeName(fnObj, wantHtml, wantLink);
             case typeKinds.Int:
                 if (wantHtml) {
@@ -1152,8 +1152,8 @@ var zigAnalysis;
             case typeKinds.Array:
             {
                 let arrayObj = /** @type {ArrayType} */(typeObj);
-                var name = "[";
-                var lenName = typeValueName(arrayObj.len, wantHtml, wantSubLink);
+                let name = "[";
+                let lenName = typeValueName(arrayObj.len, wantHtml, wantSubLink);
                 if (wantHtml) {
                     name += '' + lenName + '';
                 } else {
@@ -1169,7 +1169,7 @@ var zigAnalysis;
             case typeKinds.Pointer:
             {
                 let ptrObj = /** @type {PointerType} */(typeObj);
-                var name = "";
+                let name = "";
                 switch (ptrObj.size) {
                     default:
                         console.log("TODO: implement unhandled pointer size case");
@@ -1243,7 +1243,7 @@ var zigAnalysis;
             case typeKinds.Int:
             {
                 let intObj = /** @type {NumberType} */(typeObj);
-                var name = intObj.name;
+                let name = intObj.name;
                 if (wantHtml) {
                     return '' + name + '';
                 } else {
@@ -1316,8 +1316,8 @@ var zigAnalysis;
                 // TODO: implement error union printing assuming that both
                 // payload and error union are walk results!
                 // let errUnionObj = /** @type {ErrUnionType} */(typeObj);
-                // var errSetTypeObj = /** @type {ErrSetType} */ (zigAnalysis.types[errUnionObj.err]);
-                // var payloadHtml = typeValueName(errUnionObj.payload, wantHtml, wantSubLink, null);
+                // let errSetTypeObj = /** @type {ErrSetType} */ (zigAnalysis.types[errUnionObj.err]);
+                // let payloadHtml = typeValueName(errUnionObj.payload, wantHtml, wantSubLink, null);
                 // if (fnDecl != null && errSetTypeObj.fn === fnDecl.value.type) {
                 //     // function index parameter supplied and this is the inferred error set of it
                 //     return "!" + payloadHtml;
@@ -1328,7 +1328,7 @@ var zigAnalysis;
             case typeKinds.Fn:
             {
                 let fnObj = /** @type {Fn} */(typeObj);
-                var payloadHtml = "";
+                let payloadHtml = "";
                 if (wantHtml) {
                     payloadHtml += 'fn';
                     if (fnDecl != null) {
@@ -1346,23 +1346,23 @@ var zigAnalysis;
                 }
                 payloadHtml += '(';
                     if (fnObj.params) {
-                        var fields = null;
-                        var isVarArgs = false;
-                        var fnNode = zigAnalysis.astNodes[fnObj.src];
+                        let fields = null;
+                        let isVarArgs = false;
+                        let fnNode = zigAnalysis.astNodes[fnObj.src];
                         fields = fnNode.fields;
                         isVarArgs = fnNode.varArgs;
 
-                        for (var i = 0; i < fnObj.params.length; i += 1) {
+                        for (let i = 0; i < fnObj.params.length; i += 1) {
                             if (i != 0) {
                                 payloadHtml += ', ';
                             }
 
-                            var value = fnObj.params[i];
-                            var paramValue = resolveValue(value);
-                            var isCte = "comptimeExpr" in paramValue;
+                            let value = fnObj.params[i];
+                            let paramValue = resolveValue(value);
+                            let isCte = "comptimeExpr" in paramValue;
 
                             if (fields != null) {
-                                var paramNode = zigAnalysis.astNodes[fields[i]];
+                                let paramNode = zigAnalysis.astNodes[fields[i]];
 
                                 if (paramNode.varArgs) {
                                     payloadHtml += '...';
@@ -1385,7 +1385,7 @@ var zigAnalysis;
                                     }
                                 }
 
-                                var paramName = paramNode.name;
+                                let paramName = paramNode.name;
                                 if (paramName != null) {
                                     // skip if it matches the type name
                                     if (!shouldSkipParamName(paramValue, paramName)) {
@@ -1402,7 +1402,7 @@ var zigAnalysis;
                                 payloadHtml += '';
 
                             } else if ("type" in value) {
-                                var name = typeValueName(value, wantHtml, wantSubLink, fnDecl, linkFnNameDecl);
+                                let name = typeValueName(value, wantHtml, wantSubLink, fnDecl, linkFnNameDecl);
                                 payloadHtml += '' + escapeHtml(name) + '';
                             } else if ("comptimeExpr" in value) {
                                 payloadHtml += '[ComptimeExpr]';
@@ -1436,7 +1436,7 @@ var zigAnalysis;
 
     /** @param {Type} typeObj */
     function renderType(typeObj) {
-        var name;
+        let name;
         if (rootIsStd && typeObj === zigAnalysis.types[zigAnalysis.packages[zigAnalysis.rootPkg].main]) {
             name = "std";
         } else {
@@ -1456,10 +1456,10 @@ var zigAnalysis;
         if (errSetType.fields == null) {
             domFnErrorsAnyError.classList.remove("hidden");
         } else {
-            var errorList = [];
-            for (var i = 0; i < errSetType.fields.length; i += 1) {
-                var errObj = errSetType.fields[i];
-                //var srcObj = zigAnalysis.astNodes[errObj.src];
+            let errorList = [];
+            for (let i = 0; i < errSetType.fields.length; i += 1) {
+                let errObj = errSetType.fields[i];
+                //let srcObj = zigAnalysis.astNodes[errObj.src];
                 errorList.push(errObj);
             }
             errorList.sort(function(a, b) {
@@ -1467,11 +1467,11 @@ var zigAnalysis;
             });
 
             resizeDomListDl(domListFnErrors, errorList.length);
-            for (var i = 0; i < errorList.length; i += 1) {
-                var nameTdDom = domListFnErrors.children[i * 2 + 0];
-                var descTdDom = domListFnErrors.children[i * 2 + 1];
+            for (let i = 0; i < errorList.length; i += 1) {
+                let nameTdDom = domListFnErrors.children[i * 2 + 0];
+                let descTdDom = domListFnErrors.children[i * 2 + 1];
                 nameTdDom.textContent = errorList[i].name;
-                var docs = errorList[i].docs;
+                let docs = errorList[i].docs;
                 if (docs != null) {
                     descTdDom.innerHTML = markdown(docs);
                 } else {
@@ -1484,25 +1484,25 @@ var zigAnalysis;
     }
 
 //     function allCompTimeFnCallsHaveTypeResult(typeIndex, value) {
-//         var srcIndex = zigAnalysis.fns[value].src;
-//         var calls = nodesToCallsMap[srcIndex];
+//         let srcIndex = zigAnalysis.fns[value].src;
+//         let calls = nodesToCallsMap[srcIndex];
 //         if (calls == null) return false;
-//         for (var i = 0; i < calls.length; i += 1) {
-//             var call = zigAnalysis.calls[calls[i]];
+//         for (let i = 0; i < calls.length; i += 1) {
+//             let call = zigAnalysis.calls[calls[i]];
 //             if (call.result.type !== typeTypeId) return false;
 //         }
 //         return true;
 //     }
 //
 //     function allCompTimeFnCallsResult(calls) {
-//         var firstTypeObj = null;
-//         var containerObj = {
+//         let firstTypeObj = null;
+//         let containerObj = {
 //             privDecls: [],
 //         };
-//         for (var callI = 0; callI < calls.length; callI += 1) {
-//             var call = zigAnalysis.calls[calls[callI]];
+//         for (let callI = 0; callI < calls.length; callI += 1) {
+//             let call = zigAnalysis.calls[calls[callI]];
 //             if (call.result.type !== typeTypeId) return null;
-//             var typeObj = zigAnalysis.types[call.result.value];
+//             let typeObj = zigAnalysis.types[call.result.value];
 //             if (!typeKindIsContainer(typeObj.kind)) return null;
 //             if (firstTypeObj == null) {
 //                 firstTypeObj = typeObj;
@@ -1513,9 +1513,9 @@ var zigAnalysis;
 //
 //             if (containerObj.fields == null) {
 //                 containerObj.fields = (typeObj.fields || []).concat([]);
-//             } else for (var fieldI = 0; fieldI < typeObj.fields.length; fieldI += 1) {
-//                 var prev = containerObj.fields[fieldI];
-//                 var next = typeObj.fields[fieldI];
+//             } else for (let fieldI = 0; fieldI < typeObj.fields.length; fieldI += 1) {
+//                 let prev = containerObj.fields[fieldI];
+//                 let next = typeObj.fields[fieldI];
 //                 if (prev === next) continue;
 //                 if (typeof(prev) === 'object') {
 //                     if (prev[next] == null) prev[next] = typeObj;
@@ -1528,14 +1528,14 @@ var zigAnalysis;
 //
 //             if (containerObj.pubDecls == null) {
 //                 containerObj.pubDecls = (typeObj.pubDecls || []).concat([]);
-//             } else for (var declI = 0; declI < typeObj.pubDecls.length; declI += 1) {
-//                 var prev = containerObj.pubDecls[declI];
-//                 var next = typeObj.pubDecls[declI];
+//             } else for (let declI = 0; declI < typeObj.pubDecls.length; declI += 1) {
+//                 let prev = containerObj.pubDecls[declI];
+//                 let next = typeObj.pubDecls[declI];
 //                 if (prev === next) continue;
 //                 // TODO instead of showing "examples" as the public declarations,
 //                     // do logic like this:
 //                 //if (typeof(prev) !== 'object') {
-//                     //    var newDeclId = zigAnalysis.decls.length;
+//                     //    let newDeclId = zigAnalysis.decls.length;
 //                     //    prev = clone(zigAnalysis.decls[prev]);
 //                     //    prev.id = newDeclId;
 //                     //    zigAnalysis.decls.push(prev);
@@ -1544,8 +1544,8 @@ var zigAnalysis;
 //                 //mergeDecls(prev, next, firstTypeObj, typeObj);
 //             }
 //         }
-//         for (var declI = 0; declI < containerObj.pubDecls.length; declI += 1) {
-//             var decl = containerObj.pubDecls[declI];
+//         for (let declI = 0; declI < containerObj.pubDecls.length; declI += 1) {
+//             let decl = containerObj.pubDecls[declI];
 //             if (typeof(decl) === 'object') {
 //                 containerObj.pubDecls[declI] = containerObj.pubDecls[declI].id;
 //             }
@@ -1555,10 +1555,10 @@ var zigAnalysis;
 
 
     // function mergeDecls(declObj, nextDeclIndex, firstTypeObj, typeObj) {
-    //     var nextDeclObj = zigAnalysis.decls[nextDeclIndex];
+    //     let nextDeclObj = zigAnalysis.decls[nextDeclIndex];
     //     if (declObj.type != null && nextDeclObj.type != null && declObj.type !== nextDeclObj.type) {
     //         if (typeof(declObj.type) !== 'object') {
-    //             var prevType = declObj.type;
+    //             let prevType = declObj.type;
     //             declObj.type = {};
     //             declObj.type[prevType] = firstTypeObj;
     //             declObj.value = null;
@@ -1569,7 +1569,7 @@ var zigAnalysis;
     //     }
     //     if (declObj.value != null && nextDeclObj.value != null && declObj.value !== nextDeclObj.value) {
     //         if (typeof(declObj.value) !== 'object') {
-    //             var prevValue = declObj.value;
+    //             let prevValue = declObj.value;
     //             declObj.value = {};
     //             declObj.value[prevValue] = firstTypeObj;
     //         }
@@ -1582,8 +1582,8 @@ var zigAnalysis;
     /** @param {Decl} decl */
     function renderValue(decl) {
 
-        var declTypeRef = typeOfDecl(decl);
-        var declValueText = "";
+        let declTypeRef = typeOfDecl(decl);
+        let declValueText = "";
         switch(Object.keys(decl.value)[0]) {
             case "int":
                 declValueText += /** @type {{int: {value: number}}} */(decl.value).int.value;
@@ -1603,7 +1603,7 @@ var zigAnalysis;
             escapeHtml(decl.name) + ': ' + typeValueName(declTypeRef, true, true) +
             " = " + declValueText;
 
-        var docs = zigAnalysis.astNodes[decl.src].docs;
+        let docs = zigAnalysis.astNodes[decl.src].docs;
         if (docs != null) {
             domTldDocs.innerHTML = markdown(docs);
             domTldDocs.classList.remove("hidden");
@@ -1614,11 +1614,11 @@ var zigAnalysis;
 
     /** @param {Decl} decl */
     function renderVar(decl) {
-        var declTypeRef = typeOfDecl(decl);
+        let declTypeRef = typeOfDecl(decl);
         domFnProtoCode.innerHTML = 'var ' +
             escapeHtml(decl.name) + ': ' + typeValueName(declTypeRef, true, true);
 
-        var docs = zigAnalysis.astNodes[decl.src].docs;
+        let docs = zigAnalysis.astNodes[decl.src].docs;
         if (docs != null) {
             domTldDocs.innerHTML = markdown(docs);
             domTldDocs.classList.remove("hidden");
@@ -1642,9 +1642,9 @@ var zigAnalysis;
         typesList, namespacesList, errSetsList,
         fnsList, varsList, valsList, testsList) {
 
-        for (var i = 0; i < decls.length; i += 1) {
-            var decl = zigAnalysis.decls[decls[i]];
-            var declValue = resolveValue(decl.value);
+        for (let i = 0; i < decls.length; i += 1) {
+            let decl = zigAnalysis.decls[decls[i]];
+            let declValue = resolveValue(decl.value);
 
             if (decl.isTest) {
                 testsList.push(decl);
@@ -1676,8 +1676,8 @@ var zigAnalysis;
                 } else if (!("type" in declValue)){
                     valsList.push(decl);
                 } else {
-                    var value = zigAnalysis.types[declValue.type];
-                    var kind = value.kind;
+                    let value = zigAnalysis.types[declValue.type];
+                    let kind = value.kind;
                     if (kind === typeKinds.Fn) {
                         // TODO: handle CTE return types when we know their type.
                         const resVal = resolveValue(/** @type {Fn} */(value).ret);
@@ -1704,19 +1704,19 @@ var zigAnalysis;
      */
     function renderContainer(container) {
         /** @type {Decl[]} */
-        var typesList = [];
+        let typesList = [];
         /** @type {Decl[]} */
-        var namespacesList = [];
+        let namespacesList = [];
         /** @type {Decl[]} */
-        var errSetsList = [];
+        let errSetsList = [];
         /** @type {Decl[]} */
-        var fnsList = [];
+        let fnsList = [];
         /** @type {Decl[]} */
-        var varsList = [];
+        let varsList = [];
         /** @type {Decl[]} */
-        var valsList = [];
+        let valsList = [];
         /** @type {Decl[]} */
-        var testsList = [];
+        let testsList = [];
 
         categorizeDecls(container.pubDecls,
             typesList, namespacesList, errSetsList,
@@ -1735,7 +1735,7 @@ var zigAnalysis;
         testsList.sort(byNameProperty);
 
         if (container.src != null) {
-            var docs = zigAnalysis.astNodes[container.src].docs;
+            let docs = zigAnalysis.astNodes[container.src].docs;
             if (docs != null) {
                 domTldDocs.innerHTML = markdown(docs);
                 domTldDocs.classList.remove("hidden");
@@ -1744,10 +1744,10 @@ var zigAnalysis;
 
         if (typesList.length !== 0) {
             resizeDomList(domListTypes, typesList.length, '
    • ');
-            for (var i = 0; i < typesList.length; i += 1) {
-                var liDom = domListTypes.children[i];
-                var aDom = liDom.children[0];
-                var decl = typesList[i];
+            for (let i = 0; i < typesList.length; i += 1) {
+                let liDom = domListTypes.children[i];
+                let aDom = liDom.children[0];
+                let decl = typesList[i];
                 aDom.textContent = decl.name;
                 aDom.setAttribute('href', navLinkDecl(decl.name));
             }
@@ -1755,10 +1755,10 @@ var zigAnalysis;
         }
         if (namespacesList.length !== 0) {
             resizeDomList(domListNamespaces, namespacesList.length, '
    • ');
-            for (var i = 0; i < namespacesList.length; i += 1) {
-                var liDom = domListNamespaces.children[i];
-                var aDom = liDom.children[0];
-                var decl = namespacesList[i];
+            for (let i = 0; i < namespacesList.length; i += 1) {
+                let liDom = domListNamespaces.children[i];
+                let aDom = liDom.children[0];
+                let decl = namespacesList[i];
                 aDom.textContent = decl.name;
                 aDom.setAttribute('href', navLinkDecl(decl.name));
             }
@@ -1767,10 +1767,10 @@ var zigAnalysis;
 
         if (errSetsList.length !== 0) {
             resizeDomList(domListErrSets, errSetsList.length, '
    • ');
-            for (var i = 0; i < errSetsList.length; i += 1) {
-                var liDom = domListErrSets.children[i];
-                var aDom = liDom.children[0];
-                var decl = errSetsList[i];
+            for (let i = 0; i < errSetsList.length; i += 1) {
+                let liDom = domListErrSets.children[i];
+                let aDom = liDom.children[0];
+                let decl = errSetsList[i];
                 aDom.textContent = decl.name;
                 aDom.setAttribute('href', navLinkDecl(decl.name));
             }
@@ -1779,19 +1779,19 @@ var zigAnalysis;
 
         if (fnsList.length !== 0) {
             resizeDomList(domListFns, fnsList.length, '');
-            for (var i = 0; i < fnsList.length; i += 1) {
-                var decl = fnsList[i];
-                var trDom = domListFns.children[i];
+            for (let i = 0; i < fnsList.length; i += 1) {
+                let decl = fnsList[i];
+                let trDom = domListFns.children[i];
 
-                var tdFnCode = trDom.children[0];
-                var tdDesc = trDom.children[1];
+                let tdFnCode = trDom.children[0];
+                let tdDesc = trDom.children[1];
 
-                var declType = resolveValue(decl.value);
+                let declType = resolveValue(decl.value);
                 console.assert("type" in declType);
 
                 tdFnCode.innerHTML = typeValueName(declType, true, true, decl, navLinkDecl(decl.name));
 
-                var docs = zigAnalysis.astNodes[decl.src].docs;
+                let docs = zigAnalysis.astNodes[decl.src].docs;
                 if (docs != null) {
                     tdDesc.innerHTML = shortDescMarkdown(docs);
                 } else {
@@ -1801,29 +1801,29 @@ var zigAnalysis;
             domSectFns.classList.remove("hidden");
         }
 
-        var containerNode = zigAnalysis.astNodes[container.src];
+        let containerNode = zigAnalysis.astNodes[container.src];
         if (containerNode.fields) {
             resizeDomList(domListFields, containerNode.fields.length, '
    ');
 
-            for (var i = 0; i < containerNode.fields.length; i += 1) {
-                var fieldNode = zigAnalysis.astNodes[containerNode.fields[i]];
-                var divDom = domListFields.children[i];
+            for (let i = 0; i < containerNode.fields.length; i += 1) {
+                let fieldNode = zigAnalysis.astNodes[containerNode.fields[i]];
+                let divDom = domListFields.children[i];
                 let fieldName = /** @type {string} */(fieldNode.name);
 
-                var html = '
    ' + escapeHtml(fieldName);
+                let html = '
    ' + escapeHtml(fieldName);
 
                 if (container.kind === typeKinds.Enum) {
                     html += ' = ' + fieldName + '';
                 } else {
-                    var field = container.fields[i];
+                    let field = container.fields[i];
                     html += ": ";
-                    var name = typeValueName(field, false, false);
+                    let name = typeValueName(field, false, false);
                     html += ''+ name +'';
                 }
 
                 html += ',
    ';
 
-                var docs = fieldNode.docs;
+                let docs = fieldNode.docs;
                 if (docs != null) {
                     html += markdown(docs);
                 }
@@ -1835,21 +1835,21 @@ var zigAnalysis;
         if (varsList.length !== 0) {
             resizeDomList(domListGlobalVars, varsList.length,
                 '');
-            for (var i = 0; i < varsList.length; i += 1) {
-                var decl = varsList[i];
-                var trDom = domListGlobalVars.children[i];
+            for (let i = 0; i < varsList.length; i += 1) {
+                let decl = varsList[i];
+                let trDom = domListGlobalVars.children[i];
 
-                var tdName = trDom.children[0];
-                var tdNameA = tdName.children[0];
-                var tdType = trDom.children[1];
-                var tdDesc = trDom.children[2];
+                let tdName = trDom.children[0];
+                let tdNameA = tdName.children[0];
+                let tdType = trDom.children[1];
+                let tdDesc = trDom.children[2];
 
                 tdNameA.setAttribute('href', navLinkDecl(decl.name));
                 tdNameA.textContent = decl.name;
 
                 tdType.innerHTML = typeValueName(typeOfDecl(decl), true, true);
 
-                var docs = zigAnalysis.astNodes[decl.src].docs;
+                let docs = zigAnalysis.astNodes[decl.src].docs;
                 if (docs != null) {
                     tdDesc.innerHTML = shortDescMarkdown(docs);
                 } else {
@@ -1862,21 +1862,21 @@ var zigAnalysis;
         if (valsList.length !== 0) {
             resizeDomList(domListValues, valsList.length,
                 '');
-            for (var i = 0; i < valsList.length; i += 1) {
-                var decl = valsList[i];
-                var trDom = domListValues.children[i];
+            for (let i = 0; i < valsList.length; i += 1) {
+                let decl = valsList[i];
+                let trDom = domListValues.children[i];
 
-                var tdName = trDom.children[0];
-                var tdNameA = tdName.children[0];
-                var tdType = trDom.children[1];
-                var tdDesc = trDom.children[2];
+                let tdName = trDom.children[0];
+                let tdNameA = tdName.children[0];
+                let tdType = trDom.children[1];
+                let tdDesc = trDom.children[2];
 
                 tdNameA.setAttribute('href', navLinkDecl(decl.name));
                 tdNameA.textContent = decl.name;
 
                 tdType.innerHTML = typeValueName(typeOfDecl(decl), true, true);
 
-                var docs = zigAnalysis.astNodes[decl.src].docs;
+                let docs = zigAnalysis.astNodes[decl.src].docs;
                 if (docs != null) {
                     tdDesc.innerHTML = shortDescMarkdown(docs);
                 } else {
@@ -1889,21 +1889,21 @@ var zigAnalysis;
         if (testsList.length !== 0) {
             resizeDomList(domListTests, testsList.length,
                 '');
-            for (var i = 0; i < testsList.length; i += 1) {
-                var decl = testsList[i];
-                var trDom = domListTests.children[i];
+            for (let i = 0; i < testsList.length; i += 1) {
+                let decl = testsList[i];
+                let trDom = domListTests.children[i];
 
-                var tdName = trDom.children[0];
-                var tdNameA = tdName.children[0];
-                var tdType = trDom.children[1];
-                var tdDesc = trDom.children[2];
+                let tdName = trDom.children[0];
+                let tdNameA = tdName.children[0];
+                let tdType = trDom.children[1];
+                let tdDesc = trDom.children[2];
 
                 tdNameA.setAttribute('href', navLinkDecl(decl.name));
                 tdNameA.textContent = decl.name;
 
                 tdType.innerHTML = typeValueName(typeOfDecl(decl), true, true);
 
-                var docs = zigAnalysis.astNodes[decl.src].docs;
+                let docs = zigAnalysis.astNodes[decl.src].docs;
                 if (docs != null) {
                     tdDesc.innerHTML = shortDescMarkdown(docs);
                 } else {
@@ -1930,33 +1930,33 @@ var zigAnalysis;
     }
 
     function detectRootIsStd() {
-        var rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
+        let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
         if (rootPkg.table["std"] == null) {
             // no std mapped into the root package
             return false;
         }
-        var stdPkg = zigAnalysis.packages[rootPkg.table["std"]];
+        let stdPkg = zigAnalysis.packages[rootPkg.table["std"]];
         if (stdPkg == null) return false;
         return rootPkg.file === stdPkg.file;
     }
 
     function indexTypeKinds() {
-        var map = /** @type {Record} */({});
-        for (var i = 0; i < zigAnalysis.typeKinds.length; i += 1) {
+        let map = /** @type {Record} */({});
+        for (let i = 0; i < zigAnalysis.typeKinds.length; i += 1) {
             map[zigAnalysis.typeKinds[i]] = i;
         }
         // This is just for debugging purposes, not needed to function
-        var assertList = ["Type","Void","Bool","NoReturn","Int","Float","Pointer","Array","Struct",
+        let assertList = ["Type","Void","Bool","NoReturn","Int","Float","Pointer","Array","Struct",
             "ComptimeFloat","ComptimeInt","Undefined","Null","Optional","ErrorUnion","ErrorSet","Enum",
             "Union","Fn","BoundFn","Opaque","Frame","AnyFrame","Vector","EnumLiteral"];
-        for (var i = 0; i < assertList.length; i += 1) {
+        for (let i = 0; i < assertList.length; i += 1) {
             if (map[assertList[i]] == null) throw new Error("No type kind '" + assertList[i] + "' found");
         }
         return map;
     }
 
     function findTypeTypeId() {
-        for (var i = 0; i < zigAnalysis.types.length; i += 1) {
+        for (let i = 0; i < zigAnalysis.types.length; i += 1) {
             if (zigAnalysis.types[i].kind == typeKinds.Type) {
                 return i;
             }
@@ -1977,14 +1977,14 @@ var zigAnalysis;
         curNavSearch = "";
 
         if (location.hash[0] === '#' && location.hash.length > 1) {
-            var query = location.hash.substring(1);
+            let query = location.hash.substring(1);
             if (query[0] === '*') {
               curNav.showPrivDecls = true;
               query = query.substring(1);
             }
 
-            var qpos = query.indexOf("?");
-            var nonSearchPart;
+            let qpos = query.indexOf("?");
+            let nonSearchPart;
             if (qpos === -1) {
                 nonSearchPart = query;
             } else {
@@ -1992,7 +1992,7 @@ var zigAnalysis;
                 curNavSearch = decodeURIComponent(query.substring(qpos + 1));
             }
 
-            var parts = nonSearchPart.split(";");
+            let parts = nonSearchPart.split(";");
             curNav.pkgNames = decodeURIComponent(parts[0]).split(".");
             if (parts[1] != null) {
                 curNav.declNames = decodeURIComponent(parts[1]).split(".");
@@ -2022,17 +2022,17 @@ var zigAnalysis;
     */
     function findSubDecl(parentType, childName) {
         if (!parentType.pubDecls) return null;
-        for (var i = 0; i < parentType.pubDecls.length; i += 1) {
-            var declIndex = parentType.pubDecls[i];
-            var childDecl = zigAnalysis.decls[declIndex];
+        for (let i = 0; i < parentType.pubDecls.length; i += 1) {
+            let declIndex = parentType.pubDecls[i];
+            let childDecl = zigAnalysis.decls[declIndex];
             if (childDecl.name === childName) {
                 return childDecl;
             }
         }
         if (!parentType.privDecls) return null;
-        for (var i = 0; i < parentType.privDecls.length; i += 1) {
-            var declIndex = parentType.privDecls[i];
-            var childDecl = zigAnalysis.decls[declIndex];
+        for (let i = 0; i < parentType.privDecls.length; i += 1) {
+            let declIndex = parentType.privDecls[i];
+            let childDecl = zigAnalysis.decls[declIndex];
             if (childDecl.name === childName) {
                 return childDecl;
             }
@@ -2044,23 +2044,23 @@ var zigAnalysis;
 
 
     function computeCanonicalPackagePaths() {
-        var list = new Array(zigAnalysis.packages.length);
+        let list = new Array(zigAnalysis.packages.length);
         // Now we try to find all the packages from root.
-            var rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
+            let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
         // Breadth-first to keep the path shortest possible.
-            var stack = [{
+            let stack = [{
                 path: /** @type {string[]} */([]),
                 pkg: rootPkg,
             }];
         while (stack.length !== 0) {
-            var item = /** @type {{path: string[], pkg: Package}} */(stack.shift());
-            for (var key in item.pkg.table) {
-                var childPkgIndex = item.pkg.table[key];
+            let item = /** @type {{path: string[], pkg: Package}} */(stack.shift());
+            for (let key in item.pkg.table) {
+                let childPkgIndex = item.pkg.table[key];
                 if (list[childPkgIndex] != null) continue;
-                var childPkg = zigAnalysis.packages[childPkgIndex];
+                let childPkg = zigAnalysis.packages[childPkgIndex];
                 if (childPkg == null) continue;
 
-                var newPath = item.path.concat([key])
+                let newPath = item.path.concat([key])
                 list[childPkgIndex] = newPath;
                 stack.push({
                     path: newPath,
@@ -2074,37 +2074,37 @@ var zigAnalysis;
 
     /** @return {CanonDecl[]} */
     function computeCanonDeclPaths() {
-        var list = new Array(zigAnalysis.decls.length);
+        let list = new Array(zigAnalysis.decls.length);
         canonTypeDecls = new Array(zigAnalysis.types.length);
 
-        for (var pkgI = 0; pkgI < zigAnalysis.packages.length; pkgI += 1) {
+        for (let pkgI = 0; pkgI < zigAnalysis.packages.length; pkgI += 1) {
             if (pkgI === zigAnalysis.rootPkg && rootIsStd) continue;
-            var pkg = zigAnalysis.packages[pkgI];
-            var pkgNames = canonPkgPaths[pkgI];
-            var stack = [{
+            let pkg = zigAnalysis.packages[pkgI];
+            let pkgNames = canonPkgPaths[pkgI];
+            let stack = [{
                 declNames: /** @type {string[]} */([]),
                 type: zigAnalysis.types[pkg.main],
             }];
             while (stack.length !== 0) {
-                var item = /** @type {{declNames: string[], type: Type}} */(stack.shift());
+                let item = /** @type {{declNames: string[], type: Type}} */(stack.shift());
 
                 if (isContainerType(item.type)) {
                     let t = /** @type {ContainerType} */(item.type);
 
-                    var len = t.pubDecls ? t.pubDecls.length : 0;
-                    for (var declI = 0; declI < len; declI += 1) {
-                        var mainDeclIndex = t.pubDecls[declI];
+                    let len = t.pubDecls ? t.pubDecls.length : 0;
+                    for (let declI = 0; declI < len; declI += 1) {
+                        let mainDeclIndex = t.pubDecls[declI];
                         if (list[mainDeclIndex] != null) continue;
 
-                        var decl = zigAnalysis.decls[mainDeclIndex];
-                        var declVal = resolveValue(decl.value);
-                        var declNames = item.declNames.concat([decl.name]);
+                        let decl = zigAnalysis.decls[mainDeclIndex];
+                        let declVal = resolveValue(decl.value);
+                        let declNames = item.declNames.concat([decl.name]);
                         list[mainDeclIndex] = {
                             pkgNames: pkgNames,
                             declNames: declNames,
                         };
                         if ("type" in declVal) {
-                            var value = zigAnalysis.types[declVal.type];
+                            let value = zigAnalysis.types[declVal.type];
                             if (declCanRepresentTypeKind(value.kind))
                             {
                                 canonTypeDecls[declVal.type] = mainDeclIndex;
@@ -2149,8 +2149,8 @@ var zigAnalysis;
 
     /** @param {string} docs */
     function shortDescMarkdown(docs) {
-        var parts = docs.trim().split("\n");
-        var firstLine = parts[0];
+        let parts = docs.trim().split("\n");
+        let firstLine = parts[0];
         return markdown(firstLine);
     }
 
@@ -2172,9 +2172,9 @@ var zigAnalysis;
         // Dissect lines and determine the type for each line.
             // Also computes indentation level and removes unnecessary whitespace
 
-        var is_reading_code = false;
-        var code_indent = 0;
-        for (var line_no = 0; line_no < raw_lines.length; line_no++) {
+        let is_reading_code = false;
+        let code_indent = 0;
+        for (let line_no = 0; line_no < raw_lines.length; line_no++) {
             const raw_line = raw_lines[line_no];
 
             const line = {
@@ -2292,8 +2292,8 @@ var zigAnalysis;
             /** @type {Array} */
             const stack = [];
 
-            var innerHTML = "";
-            var currentRun = "";
+            let innerHTML = "";
+            let currentRun = "";
 
             function flushRun() {
                 if (currentRun != "") {
@@ -2302,11 +2302,11 @@ var zigAnalysis;
                 currentRun = "";
             }
 
-            var parsing_code = false;
-            var codetag = "";
-            var in_code = false;
+            let parsing_code = false;
+            let codetag = "";
+            let in_code = false;
 
-            for (var i = 0; i < innerText.length; i++) {
+            for (let i = 0; i < innerText.length; i++) {
 
                 if (parsing_code && in_code) {
                     if (innerText.substr(i, codetag.length) == codetag) {
@@ -2340,7 +2340,7 @@ var zigAnalysis;
                     currentRun += innerText[i];
                     in_code = true;
                 } else {
-                    var any = false;
+                    let any = false;
                     for (let idx = /** @type {number} */(stack.length > 0 ? -1 : 0); idx < formats.length; idx++) {
                         const fmt = idx >= 0 ? formats[idx] : stack[stack.length - 1];
                         if (innerText.substr(i, fmt.marker.length) == fmt.marker) {
@@ -2414,8 +2414,8 @@ var zigAnalysis;
             }
         }
 
-        var html = "";
-        for (var line_no = 0; line_no < lines.length; line_no++) {
+        let html = "";
+        for (let line_no = 0; line_no < lines.length; line_no++) {
             const line = lines[line_no];
 
 
@@ -2473,12 +2473,12 @@ var zigAnalysis;
             return;
         }
 
-        var liDom = domListSearchResults.children[curSearchIndex];
+        let liDom = domListSearchResults.children[curSearchIndex];
         if (liDom == null && domListSearchResults.children.length !== 0) {
             liDom = domListSearchResults.children[0];
         }
         if (liDom != null) {
-            var aDom = liDom.children[0];
+            let aDom = liDom.children[0];
             location.href = /** @type {string} */(aDom.getAttribute("href"));
             curSearchIndex = -1;
         }
@@ -2490,10 +2490,10 @@ var zigAnalysis;
         switch (getKeyString(ev)) {
             case "Enter":
                 // detect if this search changes anything
-                var terms1 = getSearchTerms();
+                let terms1 = getSearchTerms();
                 startSearch();
                 updateCurNav();
-                var terms2 = getSearchTerms();
+                let terms2 = getSearchTerms();
                 // we might have to wait for onHashChange to trigger
                 imFeelingLucky = (terms1.join(' ') !== terms2.join(' '));
                 if (!imFeelingLucky) activateSelectedResult();
@@ -2552,8 +2552,8 @@ var zigAnalysis;
 
     /** @param {KeyboardEvent} ev */
     function getKeyString(ev) {
-        var name;
-        var ignoreShift = false;
+        let name;
+        let ignoreShift = false;
         switch (ev.which) {
             case 13:
                 name = "Enter";
@@ -2622,42 +2622,42 @@ function startAsyncSearch() {
 }
 function startSearch() {
     clearAsyncSearch();
-    var oldHash = location.hash;
-    var parts = oldHash.split("?");
-    var newPart2 = (domSearch.value === "") ? "" : ("?" + domSearch.value);
+    let oldHash = location.hash;
+    let parts = oldHash.split("?");
+    let newPart2 = (domSearch.value === "") ? "" : ("?" + domSearch.value);
     location.hash = (parts.length === 1) ? (oldHash + newPart2) : (parts[0] + newPart2);
 }
 function getSearchTerms() {
-    var list = curNavSearch.trim().split(/[ \r\n\t]+/);
+    let list = curNavSearch.trim().split(/[ \r\n\t]+/);
     list.sort();
     return list;
 }
 function renderSearch() {
-    var matchedItems = [];
-    var ignoreCase = (curNavSearch.toLowerCase() === curNavSearch);
-    var terms = getSearchTerms();
+    let matchedItems = [];
+    let ignoreCase = (curNavSearch.toLowerCase() === curNavSearch);
+    let terms = getSearchTerms();
 
-    decl_loop: for (var declIndex = 0; declIndex < zigAnalysis.decls.length; declIndex += 1) {
-        var canonPath = getCanonDeclPath(declIndex);
+    decl_loop: for (let declIndex = 0; declIndex < zigAnalysis.decls.length; declIndex += 1) {
+        let canonPath = getCanonDeclPath(declIndex);
         if (canonPath == null) continue;
 
-        var decl = zigAnalysis.decls[declIndex];
-        var lastPkgName = canonPath.pkgNames[canonPath.pkgNames.length - 1];
-        var fullPathSearchText = lastPkgName + "." + canonPath.declNames.join('.');
-        var astNode = zigAnalysis.astNodes[decl.src];
-        var fileAndDocs = zigAnalysis.files[astNode.file];
+        let decl = zigAnalysis.decls[declIndex];
+        let lastPkgName = canonPath.pkgNames[canonPath.pkgNames.length - 1];
+        let fullPathSearchText = lastPkgName + "." + canonPath.declNames.join('.');
+        let astNode = zigAnalysis.astNodes[decl.src];
+        let fileAndDocs = zigAnalysis.files[astNode.file];
         if (astNode.docs != null) {
             fileAndDocs += "\n" + astNode.docs;
         }
-        var fullPathSearchTextLower = fullPathSearchText;
+        let fullPathSearchTextLower = fullPathSearchText;
         if (ignoreCase) {
             fullPathSearchTextLower = fullPathSearchTextLower.toLowerCase();
             fileAndDocs = fileAndDocs.toLowerCase();
         }
 
-        var points = 0;
-        for (var termIndex = 0; termIndex < terms.length; termIndex += 1) {
-            var term = terms[termIndex];
+        let points = 0;
+        for (let termIndex = 0; termIndex < terms.length; termIndex += 1) {
+            let term = terms[termIndex];
 
             // exact, case sensitive match of full decl path
             if (fullPathSearchText === term) {
@@ -2693,16 +2693,16 @@ function renderSearch() {
         resizeDomList(domListSearchResults, matchedItems.length, '
    • ');
 
         matchedItems.sort(function(a, b) {
-            var cmp = operatorCompare(b.points, a.points);
+            let cmp = operatorCompare(b.points, a.points);
             if (cmp != 0) return cmp;
             return operatorCompare(a.decl.name, b.decl.name);
         });
 
-        for (var i = 0; i < matchedItems.length; i += 1) {
-            var liDom = domListSearchResults.children[i];
-            var aDom = liDom.children[0];
-            var match = matchedItems[i];
-            var lastPkgName = match.path.pkgNames[match.path.pkgNames.length - 1];
+        for (let i = 0; i < matchedItems.length; i += 1) {
+            let liDom = domListSearchResults.children[i];
+            let aDom = liDom.children[0];
+            let match = matchedItems[i];
+            let lastPkgName = match.path.pkgNames[match.path.pkgNames.length - 1];
             aDom.textContent = lastPkgName + "." + match.path.declNames.join('.');
             aDom.setAttribute('href', navLink(match.path.pkgNames, match.path.declNames));
         }
@@ -2715,8 +2715,8 @@ function renderSearch() {
 }
 
 function renderSearchCursor() {
-    for (var i = 0; i < domListSearchResults.children.length; i += 1) {
-        var liDom = /** @type HTMLElement */(domListSearchResults.children[i]);
+    for (let i = 0; i < domListSearchResults.children.length; i += 1) {
+        let liDom = /** @type HTMLElement */(domListSearchResults.children[i]);
         if (curSearchIndex === i) {
             liDom.classList.add("selected");
         } else {
@@ -2728,10 +2728,10 @@ function renderSearchCursor() {
 
 
 // function indexNodesToCalls() {
-//     var map = {};
-//     for (var i = 0; i < zigAnalysis.calls.length; i += 1) {
-//         var call = zigAnalysis.calls[i];
-//         var fn = zigAnalysis.fns[call.fn];
+//     let map = {};
+//     for (let i = 0; i < zigAnalysis.calls.length; i += 1) {
+//         let call = zigAnalysis.calls[i];
+//         let fn = zigAnalysis.fns[call.fn];
 //         if (map[fn.src] == null) {
 //             map[fn.src] = [i];
 //         } else {
@@ -2757,8 +2757,8 @@ function byNameProperty(a, b) {
  * @returns {T}
  */
 function clone(obj) {
-    var res = /** @type T */({});
-    for (var key in obj) {
+    let res = /** @type T */({});
+    for (let key in obj) {
         res[key] = obj[key];
     }
     return res;

From cc71003cfcd8af8e037dd127ea627113fbc17103 Mon Sep 17 00:00:00 2001
From: Loris Cro 
Date: Sun, 3 Apr 2022 18:46:03 +0200
Subject: [PATCH 050/137] autodoc: improved rendering container fields and
 fixed rendering of func args

---
 lib/docs/main.js | 67 ++++++++++++++++++++++++++++++------------------
 1 file changed, 42 insertions(+), 25 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index f7a434ae06..449b8a8081 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -391,8 +391,35 @@ var zigAnalysis;
         return isType(x) && typeKindIsContainer(/** @type {Type} */(x).kind) ;
     }
 
-    /** @param {Type} type */
-    function typeShorthandName(type) {
+    /** @param {WalkResult} wr */
+    function typeShorthandName(wr) {
+        let resolvedWr = resolveValue(wr);
+        if (!("type" in resolvedWr)) {
+            return null;
+        }
+        let type = /** @type {Type} */(zigAnalysis.types[resolvedWr.type]);
+
+        outer: for (let i = 0; i < 10000; i += 1) {
+            switch (type.kind) {
+                case typeKinds.Optional:
+                case typeKinds.Pointer:
+                    let child = /** @type {PointerType | OptionalType} */(type).child;
+                    let resolvedChild = resolveValue(child);
+                    if ("type" in resolvedChild) {
+                        type = zigAnalysis.types[resolvedChild.type];
+                        continue;
+                    } else {
+                        return null;
+                    }
+                default:
+                    break outer;
+            }
+
+            if (i == 9999) throw "Exhausted typeShorthandName quota";
+        }
+
+
+
         let name = undefined;
         if (type.kind === typeKinds.Struct) {
             name = "struct";
@@ -401,8 +428,10 @@ var zigAnalysis;
         } else if (type.kind === typeKinds.Union) {
             name = "union";
         } else {
-            name = /** @type {any} */(type).name;
+            console.log("TODO: unhalndled case in typeShortName");
+            return null;
         }
+
         return escapeHtml(name);
     }
 
@@ -954,8 +983,7 @@ var zigAnalysis;
     */
     function resizeDomListDl(dlDom, desiredLen) {
         // add the missing dom entries
-        let i, ev;
-        for (i = dlDom.childElementCount / 2; i < desiredLen; i += 1) {
+        for (let i = dlDom.childElementCount / 2; i < desiredLen; i += 1) {
             dlDom.insertAdjacentHTML('beforeend', '
    ');
         }
         // remove extra dom entries
@@ -972,8 +1000,7 @@ var zigAnalysis;
     */
     function resizeDomList(listDom, desiredLen, templateHtml) {
         // add the missing dom entries
-        let i, ev;
-        for (i = listDom.childElementCount; i < desiredLen; i += 1) {
+        for (let i = listDom.childElementCount; i < desiredLen; i += 1) {
             listDom.insertAdjacentHTML('beforeend', templateHtml);
         }
         // remove extra dom entries
@@ -1050,7 +1077,6 @@ var zigAnalysis;
         console.assert("type" in typeValue)
         let typeIndex = typeValue.type;
         let typeObj = zigAnalysis.types[typeIndex];
-        let declNameOk = declCanRepresentTypeKind(typeObj.kind);
         if (wantLink) {
             let declIndex = getCanonTypeDecl(typeIndex);
             let declPath = getCanonDeclPath(declIndex);
@@ -1359,7 +1385,6 @@ var zigAnalysis;
 
                             let value = fnObj.params[i];
                             let paramValue = resolveValue(value);
-                            let isCte = "comptimeExpr" in paramValue;
 
                             if (fields != null) {
                                 let paramNode = zigAnalysis.astNodes[fields[i]];
@@ -1402,7 +1427,7 @@ var zigAnalysis;
                                 payloadHtml += '';
 
                             } else if ("type" in value) {
-                                let name = typeValueName(value, wantHtml, wantSubLink, fnDecl, linkFnNameDecl);
+                                let name = typeValueName(value, false, false, fnDecl, linkFnNameDecl);
                                 payloadHtml += '' + escapeHtml(name) + '';
                             } else if ("comptimeExpr" in value) {
                                 payloadHtml += '[ComptimeExpr]';
@@ -1815,10 +1840,15 @@ var zigAnalysis;
                 if (container.kind === typeKinds.Enum) {
                     html += ' = ' + fieldName + '';
                 } else {
-                    let field = container.fields[i];
+                    let fieldTypeWr = container.fields[i];
                     html += ": ";
-                    let name = typeValueName(field, false, false);
+                    let name = typeValueName(fieldTypeWr, false, false);
                     html += ''+ name +'';
+                    let tsn = typeShorthandName(fieldTypeWr);
+                    if (tsn) {
+                        html += ' ('+ tsn +')';
+
+                    }
                 }
 
                 html += ',
    ';
@@ -2751,18 +2781,5 @@ function byNameProperty(a, b) {
 }
 
 
-/**
- * @template T
- * @param {T} obj
- * @returns {T}
- */
-function clone(obj) {
-    let res = /** @type T */({});
-    for (let key in obj) {
-        res[key] = obj[key];
-    }
-    return res;
-}
-
 
 })();

From ae4b5c29b27990cdb5b0b517965bd6a21294d35a Mon Sep 17 00:00:00 2001
From: Loris Cro 
Date: Mon, 18 Apr 2022 17:36:36 +0200
Subject: [PATCH 051/137] autodoc: fix final js type error

---
 lib/docs/main.js | 118 +++++++++++++++++++++++------------------------
 1 file changed, 59 insertions(+), 59 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 449b8a8081..ea90a9fbc1 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -268,7 +268,7 @@ var zigAnalysis;
     let domTableFnErrors =/** @type HTMLElement */(document.getElementById("tableFnErrors"));
     let domFnErrorsAnyError = /** @type HTMLElement */(document.getElementById("fnErrorsAnyError"));
     let domFnExamples = /** @type HTMLElement */(document.getElementById("fnExamples"));
-    let domListFnExamples = /** @type HTMLElement */(document.getElementById("listFnExamples"));
+    // let domListFnExamples = /** @type HTMLElement */(document.getElementById("listFnExamples"));
     let domFnNoExamples = /** @type HTMLElement */(document.getElementById("fnNoExamples"));
     let domDeclNoRef = /** @type HTMLElement */(document.getElementById("declNoRef"));
     let domSearch = /** @type HTMLInputElement */(document.getElementById("search"));
@@ -277,7 +277,7 @@ var zigAnalysis;
     let domListSearchResults = /** @type HTMLElement */(document.getElementById("listSearchResults"));
     let domSectSearchNoResults = /** @type HTMLElement */(document.getElementById("sectSearchNoResults"));
     let domSectInfo = /** @type HTMLElement */(document.getElementById("sectInfo"));
-    let domTdTarget = /** @type HTMLElement */(document.getElementById("tdTarget"));
+    // let domTdTarget = /** @type HTMLElement */(document.getElementById("tdTarget"));
     let domPrivDeclsBox = /** @type HTMLInputElement */(document.getElementById("privDeclsBox"));
     let domTdZigVer = /** @type HTMLElement */(document.getElementById("tdZigVer"));
     let domHdrName = /** @type HTMLElement */(document.getElementById("hdrName"));
@@ -447,21 +447,21 @@ var zigAnalysis;
         return typeKind === typeKinds.ErrorSet || typeKindIsContainer(typeKind);
     }
 
-    /**
-        * @param {WalkResult[]} path
-        * @return {WalkResult | null}
-    */
-    function findCteInRefPath(path) {
-        for (let i = path.length - 1; i >= 0; i -= 1) {
-            const ref = path[i];
-            if ("string" in ref) continue;
-            if ("comptimeExpr" in ref) return ref;
-            if ("refPath" in ref) return findCteInRefPath(ref.refPath);
-            return null;
-        }
+    // /**
+    //     * @param {WalkResult[]} path
+    //     * @return {WalkResult | null}
+    // */
+    // function findCteInRefPath(path) {
+    //     for (let i = path.length - 1; i >= 0; i -= 1) {
+    //         const ref = path[i];
+    //         if ("string" in ref) continue;
+    //         if ("comptimeExpr" in ref) return ref;
+    //         if ("refPath" in ref) return findCteInRefPath(ref.refPath);
+    //         return null;
+    //     }
 
-        return null;
-    }
+    //     return null;
+    // }
 
     /**
         * @param {WalkResult} value
@@ -960,22 +960,22 @@ var zigAnalysis;
         return navLink(curNav.pkgNames, curNav.declNames.concat([childName]));
     }
 
-    /** @param {Call} callObj */
-    function navLinkCall(callObj) {
-        let declNamesCopy = curNav.declNames.concat([]);
-        let callName = /** @type {string} */(declNamesCopy.pop());
+   //  /** @param {Call} callObj */
+   //  function navLinkCall(callObj) {
+   //      let declNamesCopy = curNav.declNames.concat([]);
+   //      let callName = /** @type {string} */(declNamesCopy.pop());
 
-        callName += '(';
-            for (let arg_i = 0; arg_i < callObj.args.length; arg_i += 1) {
-                if (arg_i !== 0) callName += ',';
-                let argObj = callObj.args[arg_i];
-                callName += getValueText(argObj, argObj, false, false);
-            }
-            callName += ')';
+   //      callName += '(';
+   //          for (let arg_i = 0; arg_i < callObj.args.length; arg_i += 1) {
+   //              if (arg_i !== 0) callName += ',';
+   //              let argObj = callObj.args[arg_i];
+   //              callName += getValueText(argObj, argObj, false, false);
+   //          }
+   //          callName += ')';
 
-        declNamesCopy.push(callName);
-        return navLink(curNav.pkgNames, declNamesCopy);
-    }
+   //      declNamesCopy.push(callName);
+   //      return navLink(curNav.pkgNames, declNamesCopy);
+   //  }
 
     /**
     * @param {any} dlDom
@@ -1135,35 +1135,35 @@ var zigAnalysis;
     //         return html;
     //     }
 
-    /**
-    * @param {WalkResult} typeRef
-    * @param {any} value
-    * @param {boolean} wantHtml
-    * @param {boolean} wantLink
-    */
-    function getValueText(typeRef, value, wantHtml, wantLink) {
-        let resolvedTypeRef = resolveValue(typeRef);
-        if ("comptimeExpr" in resolvedTypeRef) {
-            return "[ComptimeExpr]";
-        }
-        console.assert("type" in resolvedTypeRef);
-        let typeObj = zigAnalysis.types[typeRef.type];
-        switch (typeObj.kind) {
-            case typeKinds.Type:
-                return typeValueName(value, wantHtml, wantLink);
-            case typeKinds.Fn:
-                let fnObj = zigAnalysis.fns[value];
-                return typeName(fnObj, wantHtml, wantLink);
-            case typeKinds.Int:
-                if (wantHtml) {
-                    return '' + value + '';
-                } else {
-                    return value + "";
-                }
-            default:
-                console.trace("TODO implement getValueText for this type:", zigAnalysis.typeKinds[typeObj.kind]);
-        }
-    }
+   //  /**
+   //  * @param {WalkResult} typeRef
+   //  * @param {any} value
+   //  * @param {boolean} wantHtml
+   //  * @param {boolean} wantLink
+   //  */
+   //  function getValueText(typeRef, value, wantHtml, wantLink) {
+   //      let resolvedTypeRef = resolveValue(typeRef);
+   //      if ("comptimeExpr" in resolvedTypeRef) {
+   //          return "[ComptimeExpr]";
+   //      }
+   //      console.assert("type" in resolvedTypeRef);
+   //      let typeObj = zigAnalysis.types[typeRef.type];
+   //      switch (typeObj.kind) {
+   //          case typeKinds.Type:
+   //              return typeValueName(value, wantHtml, wantLink);
+   //          case typeKinds.Fn:
+   //              let fnObj = zigAnalysis.fns[value];
+   //              return typeName(fnObj, wantHtml, wantLink);
+   //          case typeKinds.Int:
+   //              if (wantHtml) {
+   //                  return '' + value + '';
+   //              } else {
+   //                  return value + "";
+   //              }
+   //          default:
+   //              console.trace("TODO implement getValueText for this type:", zigAnalysis.typeKinds[typeObj.kind]);
+   //      }
+   //  }
 
     /**
     * @param {Type} typeObj,

From 0339e1c7d4fc3cc2144f4f5aae335b16fa808531 Mon Sep 17 00:00:00 2001
From: Loris Cro 
Date: Sun, 15 May 2022 22:57:12 +0200
Subject: [PATCH 052/137] update to new code from master branch

---
 src/Autodoc.zig | 80 ++++++++++++++++++++++++-------------------------
 1 file changed, 40 insertions(+), 40 deletions(-)

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 206728a7b0..3ab334a0f3 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -85,7 +85,7 @@ pub fn generateZirData(self: *Autodoc) !void {
         var i: u32 = 1;
         while (i <= @enumToInt(Ref.anyerror_void_error_union_type)) : (i += 1) {
             var tmpbuf = std.ArrayList(u8).init(self.arena);
-            try Ref.typed_value_map[i].val.format("", .{}, tmpbuf.writer());
+            try Ref.typed_value_map[i].val.fmtDebug().format("", .{}, tmpbuf.writer());
             try self.types.append(
                 self.arena,
                 switch (@intToEnum(Ref, i)) {
@@ -224,11 +224,11 @@ pub fn generateZirData(self: *Autodoc) !void {
     ) catch unreachable;
     out.print(";", .{}) catch unreachable;
     // copy main.js, index.html
-    const special = try self.module.comp.zig_lib_directory.join(self.arena, &.{ "std", "special", "docs", std.fs.path.sep_str });
-    var special_dir = std.fs.openDirAbsolute(special, .{}) catch unreachable;
-    defer special_dir.close();
-    special_dir.copyFile("main.js", output_dir, "main.js", .{}) catch unreachable;
-    special_dir.copyFile("index.html", output_dir, "index.html", .{}) catch unreachable;
+    const docs = try self.module.comp.zig_lib_directory.join(self.arena, &.{ "docs", std.fs.path.sep_str });
+    var docs_dir = std.fs.openDirAbsolute(docs, .{}) catch unreachable;
+    defer docs_dir.close();
+    docs_dir.copyFile("main.js", output_dir, "main.js", .{}) catch unreachable;
+    docs_dir.copyFile("index.html", output_dir, "index.html", .{}) catch unreachable;
 }
 
 /// Represents a chain of scopes, used to resolve decl references to the
@@ -1208,33 +1208,33 @@ fn walkInstruction(
                 },
 
                 .opaque_decl => return self.cteTodo("opaque {...}"),
-                .func => {
-                    const type_slot_index = self.types.items.len;
-                    try self.types.append(self.arena, .{ .Unanalyzed = {} });
-
-                    const result = try self.analyzeFunction(
-                        file,
-                        parent_scope,
-                        inst_index,
-                        self_ast_node_index,
-                        type_slot_index,
-                    );
-                    if (self.ref_paths_pending_on_types.get(type_slot_index)) |paths| {
-                        for (paths.items) |resume_info| {
-                            try self.tryResolveRefPath(
-                                resume_info.file,
-                                inst_index,
-                                resume_info.ref_path,
-                            );
-                        }
-
-                        _ = self.ref_paths_pending_on_types.remove(type_slot_index);
-                        // TODO: we should deallocate the arraylist that holds all the
-                        //       decl paths. not doing it now since it's arena-allocated
-                        //       anyway, but maybe we should put it elsewhere.
-                    }
-                    return result;
-                },
+                //                .func => {
+                //                    const type_slot_index = self.types.items.len;
+                //                    try self.types.append(self.arena, .{ .Unanalyzed = {} });
+                //
+                //                    const result = try self.analyzeFunction(
+                //                        file,
+                //                        parent_scope,
+                //                        inst_index,
+                //                        self_ast_node_index,
+                //                        type_slot_index,
+                //                    );
+                //                    if (self.ref_paths_pending_on_types.get(type_slot_index)) |paths| {
+                //                        for (paths.items) |resume_info| {
+                //                            try self.tryResolveRefPath(
+                //                                resume_info.file,
+                //                                inst_index,
+                //                                resume_info.ref_path,
+                //                            );
+                //                        }
+                //
+                //                        _ = self.ref_paths_pending_on_types.remove(type_slot_index);
+                //                        // TODO: we should deallocate the arraylist that holds all the
+                //                        //       decl paths. not doing it now since it's arena-allocated
+                //                        //       anyway, but maybe we should put it elsewhere.
+                //                    }
+                //                    return result;
+                //                },
                 .variable => {
                     const small = @bitCast(Zir.Inst.ExtendedVar.Small, extended.small);
                     var extra_index: usize = extended.operand;
@@ -1731,16 +1731,16 @@ fn walkDecls(
                         const func_index = getBlockInlineBreak(file.zir, value_index);
                         // a decltest is always a function
                         const tag = file.zir.instructions.items(.tag)[Zir.refToIndex(func_index).?];
-                        std.debug.assert(tag == .extended);
+                        std.debug.assert(tag == .func_extended);
 
-                        const extended = file.zir.instructions.items(.data)[Zir.refToIndex(func_index).?].extended;
-                        const extra = file.zir.extraData(Zir.Inst.ExtendedFunc, extended.operand);
-                        const small = @bitCast(Zir.Inst.ExtendedFunc.Small, extended.small);
+                        const pl_node = file.zir.instructions.items(.data)[Zir.refToIndex(func_index).?].pl_node;
+                        const extra = file.zir.extraData(Zir.Inst.ExtendedFunc, pl_node.payload_index);
+                        const bits = @bitCast(Zir.Inst.ExtendedFunc.Bits, extra.data.bits);
 
                         var extra_index_for_this_func: usize = extra.end;
-                        if (small.has_lib_name) extra_index_for_this_func += 1;
-                        if (small.has_cc) extra_index_for_this_func += 1;
-                        if (small.has_align) extra_index_for_this_func += 1;
+                        if (bits.has_lib_name) extra_index_for_this_func += 1;
+                        if (bits.has_cc) extra_index_for_this_func += 1;
+                        if (bits.has_align) extra_index_for_this_func += 1;
 
                         const ret_ty_body = file.zir.extra[extra_index_for_this_func..][0..extra.data.ret_body_len];
                         extra_index_for_this_func += ret_ty_body.len;

From cf685c1132113b867f1476f4cd9d7a47d96a4782 Mon Sep 17 00:00:00 2001
From: Loris Cro 
Date: Wed, 18 May 2022 18:55:13 +0200
Subject: [PATCH 053/137] autodoc: collect type information for some
 expressions

---
 lib/docs/main.js | 647 ++++++++++++++++++++++++---------------------
 src/Autodoc.zig  | 671 ++++++++++++++++++++++++-----------------------
 2 files changed, 692 insertions(+), 626 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index ea90a9fbc1..ded13b7799 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -494,6 +494,8 @@ var zigAnalysis;
         * @return {WalkResult}
     */
     function typeOfDecl(decl){
+        return decl.value.typeRef;
+
         let i = 0;
         while(i < 1000) {
             i += 1;
@@ -502,6 +504,13 @@ var zigAnalysis;
                 return /** @type {WalkResult} */({ type: typeTypeId });
             }
 
+//            if ("string" in decl.value) {
+//                return /** @type {WalkResult} */({ type: {
+//                  kind: typeKinds.Pointer,
+//                  size: pointerSizeEnum.One,
+//                  child: });
+//            }
+
             if ("refPath" in decl.value) {
                 decl =  /** @type {Decl} */({
                   value: decl.value.refPath[decl.value.refPath.length -1]
@@ -1009,6 +1018,327 @@ var zigAnalysis;
         }
     }
 
+     /**
+    * @typedef {{
+        wantHtml: boolean,
+    }} RenderWrOptions
+    * @param {WalkResult} wr,
+    * @param {RenderWrOptions} opts,
+    * @return {string}
+    */
+
+    function exprName(expr, opts) {
+        const activeField = Object.keys(expr)[0];
+        switch (activeField) {
+          case "int": {
+              return "" + expr.int;
+          }
+          case "string": {
+            return "\"" + escapeHtml(expr.string) + "\"";
+          }
+
+          case "anytype": {
+            return "anytype";
+          }
+
+          case "this":{
+            return "this";
+          }
+
+          case "type": {
+              let name = "";
+              const typeObj = zigAnalysis.types[expr.type];
+              switch (typeObj.kind) {
+                  case typeKinds.Array:
+                  {
+                      let arrayObj = /** @type {ArrayType} */(typeObj);
+                      let name = "[";
+                      let lenName = exprName(arrayObj.len, opts);
+                      if (opts.wantHtml) {
+                          name += '' + lenName + '';
+                      } else {
+                          name += lenName;
+                      }
+                      name += "]";
+                      name += exprName(arrayObj.child, opts);
+                      return name;
+                  }
+                  case typeKinds.Optional:
+
+                      return "?" + typeValueName(/**@type {OptionalType} */(typeObj).child, wantHtml, wantSubLink, fnDecl, linkFnNameDecl);
+                  case typeKinds.Pointer:
+                  {
+                      let ptrObj = /** @type {PointerType} */(typeObj);
+                      let name = "";
+                      switch (ptrObj.size) {
+                          default:
+                              console.log("TODO: implement unhandled pointer size case");
+                          case pointerSizeEnum.One:
+                              name += "*";
+                              break;
+                          case pointerSizeEnum.Many:
+                              name += "[*]";
+                              break;
+                          case pointerSizeEnum.Slice:
+                              name += "[]";
+                              break;
+                          case pointerSizeEnum.C:
+                              name += "[*c]";
+                              break;
+                      }
+                      if (ptrObj['const']) {
+                          if (opts.wantHtml) {
+                              name += 'const ';
+                          } else {
+                              name += "const ";
+                          }
+                      }
+                      if (ptrObj['volatile']) {
+                          if (opts.wantHtml) {
+                              name += 'volatile ';
+                          } else {
+                              name += "volatile ";
+                          }
+                      }
+                      if (ptrObj.align != null) {
+                          if (opts.wantHtml) {
+                              name += 'align(';
+                          } else {
+                              name += "align(";
+                          }
+                          if (opts.wantHtml) {
+                              name += '' + ptrObj.align + '';
+                          } else {
+                              name += ptrObj.align;
+                          }
+                          if (ptrObj.hostIntBytes != null) {
+                              name += ":";
+                              if (opts.wantHtml) {
+                                  name += '' + ptrObj.bitOffsetInHost + '';
+                              } else {
+                                  name += ptrObj.bitOffsetInHost;
+                              }
+                              name += ":";
+                              if (opts.wantHtml) {
+                                  name += '' + ptrObj.hostIntBytes + '';
+                              } else {
+                                  name += ptrObj.hostIntBytes;
+                              }
+                          }
+                          name += ") ";
+                      }
+                      //name += typeValueName(ptrObj.child, wantHtml, wantSubLink, null);
+                      name += exprName(ptrObj.child, opts);
+                      return name;
+                  }
+                  case typeKinds.Float:
+                  {
+                      let floatObj = /** @type {NumberType} */ (typeObj);
+
+                      if (wantHtml) {
+                          return '' + floatObj.name + '';
+                      } else {
+                          return floatObj.name;
+                      }
+                  }
+                  case typeKinds.Int:
+                  {
+                      let intObj = /** @type {NumberType} */(typeObj);
+                      let name = intObj.name;
+                      if (opts.wantHtml) {
+                          return '' + name + '';
+                      } else {
+                          return name;
+                      }
+                  }
+                  case typeKinds.ComptimeInt:
+                      if (wantHtml) {
+                          return 'comptime_int';
+                      } else {
+                          return "comptime_int";
+                      }
+                  case typeKinds.ComptimeFloat:
+                      if (wantHtml) {
+                          return 'comptime_float';
+                      } else {
+                          return "comptime_float";
+                      }
+                  case typeKinds.Type:
+                      if (wantHtml) {
+                          return 'type';
+                      } else {
+                          return "type";
+                      }
+                  case typeKinds.Bool:
+                      if (wantHtml) {
+                          return 'bool';
+                      } else {
+                          return "bool";
+                      }
+                  case typeKinds.Void:
+                      if (wantHtml) {
+                          return 'void';
+                      } else {
+                          return "void";
+                      }
+                  case typeKinds.EnumLiteral:
+                      if (wantHtml) {
+                          return '(enum literal)';
+                      } else {
+                          return "(enum literal)";
+                      }
+                  case typeKinds.NoReturn:
+                      if (wantHtml) {
+                          return 'noreturn';
+                      } else {
+                          return "noreturn";
+                      }
+                  case typeKinds.ErrorSet:
+                  {
+                      let errSetObj = /** @type {ErrSetType} */(typeObj);
+                      if (errSetObj.fields == null) {
+                          if (wantHtml) {
+                              return 'anyerror';
+                          } else {
+                              return "anyerror";
+                          }
+                      } else {
+                          throw "TODO";
+                          // if (wantHtml) {
+                          //     return escapeHtml(typeObj.name);
+                          // } else {
+                          //     return typeObj.name;
+                          // }
+                      }
+                  }
+                  case typeKinds.ErrorUnion:
+                  {
+                      throw "TODO";
+                      // TODO: implement error union printing assuming that both
+                      // payload and error union are walk results!
+                      // let errUnionObj = /** @type {ErrUnionType} */(typeObj);
+                      // let errSetTypeObj = /** @type {ErrSetType} */ (zigAnalysis.types[errUnionObj.err]);
+                      // let payloadHtml = typeValueName(errUnionObj.payload, wantHtml, wantSubLink, null);
+                      // if (fnDecl != null && errSetTypeObj.fn === fnDecl.value.type) {
+                      //     // function index parameter supplied and this is the inferred error set of it
+                      //     return "!" + payloadHtml;
+                      // } else {
+                      //     return typeValueName(errUnionObj.err, wantHtml, wantSubLink, null) + "!" + payloadHtml;
+                      // }
+                  }
+                  case typeKinds.Fn:
+                  {
+                      let fnObj = /** @type {Fn} */(typeObj);
+                      let payloadHtml = "";
+                      if (wantHtml) {
+                          payloadHtml += 'fn';
+                          if (fnDecl != null) {
+                              payloadHtml += ' ';
+                              if (linkFnNameDecl != null) {
+                                  payloadHtml += '' +
+                                      escapeHtml(fnDecl.name) + '';
+                              } else {
+                                  payloadHtml += escapeHtml(fnDecl.name);
+                              }
+                              payloadHtml += '';
+                          }
+                      } else {
+                          payloadHtml += 'fn'
+                      }
+                      payloadHtml += '(';
+                          if (fnObj.params) {
+                              let fields = null;
+                              let isVarArgs = false;
+                              let fnNode = zigAnalysis.astNodes[fnObj.src];
+                              fields = fnNode.fields;
+                              isVarArgs = fnNode.varArgs;
+
+                              for (let i = 0; i < fnObj.params.length; i += 1) {
+                                  if (i != 0) {
+                                      payloadHtml += ', ';
+                                  }
+
+                                  let value = fnObj.params[i];
+                                  let paramValue = resolveValue(value);
+
+                                  if (fields != null) {
+                                      let paramNode = zigAnalysis.astNodes[fields[i]];
+
+                                      if (paramNode.varArgs) {
+                                          payloadHtml += '...';
+                                          continue;
+                                      }
+
+                                      if (paramNode.noalias) {
+                                          if (wantHtml) {
+                                              payloadHtml += 'noalias ';
+                                          } else {
+                                              payloadHtml += 'noalias ';
+                                          }
+                                      }
+
+                                      if (paramNode.comptime) {
+                                          if (wantHtml) {
+                                              payloadHtml += 'comptime ';
+                                          } else {
+                                              payloadHtml += 'comptime ';
+                                          }
+                                      }
+
+                                      let paramName = paramNode.name;
+                                      if (paramName != null) {
+                                          // skip if it matches the type name
+                                          if (!shouldSkipParamName(paramValue, paramName)) {
+                                              payloadHtml += paramName + ': ';
+                                          }
+                                      }
+                                  }
+
+                                  if (isVarArgs && i === fnObj.params.length - 1) {
+                                      payloadHtml += '...';
+                                  } else if ("refPath" in value) {
+                                      payloadHtml += '';
+                                      payloadHtml += '[Ref Path]';
+                                      payloadHtml += '';
+
+                                  } else if ("type" in value) {
+                                      let name = typeValueName(value, false, false, fnDecl, linkFnNameDecl);
+                                      payloadHtml += '' + escapeHtml(name) + '';
+                                  } else if ("comptimeExpr" in value) {
+                                      payloadHtml += '[ComptimeExpr]';
+                                  } else if (wantHtml) {
+                                      payloadHtml += 'var';
+                                  } else {
+                                      payloadHtml += 'var';
+                                  }
+                              }
+                          }
+
+                      payloadHtml += ') ';
+                      if (fnObj.ret != null) {
+                          payloadHtml += typeValueName(fnObj.ret, wantHtml, wantSubLink, fnDecl);
+                      } else if (wantHtml) {
+                          payloadHtml += 'anytype';
+                      } else {
+                          payloadHtml += 'anytype';
+                      }
+                      return payloadHtml;
+                  }
+                  default:
+                      throw "TODO";
+                      // if (wantHtml) {
+                      //     return escapeHtml(typeObj.name);
+                      // } else {
+                      //     return typeObj.name;
+                      // }
+              }
+        }
+
+          default: throw "oh no";
+        }
+    }
+
+
     /**
     * @param {WalkResult} typeValue,
     * @param {boolean} wantHtml,
@@ -1174,289 +1504,6 @@ var zigAnalysis;
     * @return {string}
     */
     function typeName(typeObj, wantHtml, wantSubLink, fnDecl, linkFnNameDecl) {
-        switch (typeObj.kind) {
-            case typeKinds.Array:
-            {
-                let arrayObj = /** @type {ArrayType} */(typeObj);
-                let name = "[";
-                let lenName = typeValueName(arrayObj.len, wantHtml, wantSubLink);
-                if (wantHtml) {
-                    name += '' + lenName + '';
-                } else {
-                    name += lenName;
-                }
-                name += "]";
-                name += typeValueName(arrayObj.child, wantHtml, wantSubLink, null);
-                return name;
-            }
-            case typeKinds.Optional:
-
-                return "?" + typeValueName(/**@type {OptionalType} */(typeObj).child, wantHtml, wantSubLink, fnDecl, linkFnNameDecl);
-            case typeKinds.Pointer:
-            {
-                let ptrObj = /** @type {PointerType} */(typeObj);
-                let name = "";
-                switch (ptrObj.size) {
-                    default:
-                        console.log("TODO: implement unhandled pointer size case");
-                    case pointerSizeEnum.One:
-                        name += "*";
-                        break;
-                    case pointerSizeEnum.Many:
-                        name += "[*]";
-                        break;
-                    case pointerSizeEnum.Slice:
-                        name += "[]";
-                        break;
-                    case pointerSizeEnum.C:
-                        name += "[*c]";
-                        break;
-                }
-                if (ptrObj['const']) {
-                    if (wantHtml) {
-                        name += 'const ';
-                    } else {
-                        name += "const ";
-                    }
-                }
-                if (ptrObj['volatile']) {
-                    if (wantHtml) {
-                        name += 'volatile ';
-                    } else {
-                        name += "volatile ";
-                    }
-                }
-                if (ptrObj.align != null) {
-                    if (wantHtml) {
-                        name += 'align(';
-                    } else {
-                        name += "align(";
-                    }
-                    if (wantHtml) {
-                        name += '' + ptrObj.align + '';
-                    } else {
-                        name += ptrObj.align;
-                    }
-                    if (ptrObj.hostIntBytes != null) {
-                        name += ":";
-                        if (wantHtml) {
-                            name += '' + ptrObj.bitOffsetInHost + '';
-                        } else {
-                            name += ptrObj.bitOffsetInHost;
-                        }
-                        name += ":";
-                        if (wantHtml) {
-                            name += '' + ptrObj.hostIntBytes + '';
-                        } else {
-                            name += ptrObj.hostIntBytes;
-                        }
-                    }
-                    name += ") ";
-                }
-                name += typeValueName(ptrObj.child, wantHtml, wantSubLink, null);
-                return name;
-            }
-            case typeKinds.Float:
-            {
-                let floatObj = /** @type {NumberType} */ (typeObj);
-
-                if (wantHtml) {
-                    return '' + floatObj.name + '';
-                } else {
-                    return floatObj.name;
-                }
-            }
-            case typeKinds.Int:
-            {
-                let intObj = /** @type {NumberType} */(typeObj);
-                let name = intObj.name;
-                if (wantHtml) {
-                    return '' + name + '';
-                } else {
-                    return name;
-                }
-            }
-            case typeKinds.ComptimeInt:
-                if (wantHtml) {
-                    return 'comptime_int';
-                } else {
-                    return "comptime_int";
-                }
-            case typeKinds.ComptimeFloat:
-                if (wantHtml) {
-                    return 'comptime_float';
-                } else {
-                    return "comptime_float";
-                }
-            case typeKinds.Type:
-                if (wantHtml) {
-                    return 'type';
-                } else {
-                    return "type";
-                }
-            case typeKinds.Bool:
-                if (wantHtml) {
-                    return 'bool';
-                } else {
-                    return "bool";
-                }
-            case typeKinds.Void:
-                if (wantHtml) {
-                    return 'void';
-                } else {
-                    return "void";
-                }
-            case typeKinds.EnumLiteral:
-                if (wantHtml) {
-                    return '(enum literal)';
-                } else {
-                    return "(enum literal)";
-                }
-            case typeKinds.NoReturn:
-                if (wantHtml) {
-                    return 'noreturn';
-                } else {
-                    return "noreturn";
-                }
-            case typeKinds.ErrorSet:
-            {
-                let errSetObj = /** @type {ErrSetType} */(typeObj);
-                if (errSetObj.fields == null) {
-                    if (wantHtml) {
-                        return 'anyerror';
-                    } else {
-                        return "anyerror";
-                    }
-                } else {
-                    throw "TODO";
-                    // if (wantHtml) {
-                    //     return escapeHtml(typeObj.name);
-                    // } else {
-                    //     return typeObj.name;
-                    // }
-                }
-            }
-            case typeKinds.ErrorUnion:
-            {
-                throw "TODO";
-                // TODO: implement error union printing assuming that both
-                // payload and error union are walk results!
-                // let errUnionObj = /** @type {ErrUnionType} */(typeObj);
-                // let errSetTypeObj = /** @type {ErrSetType} */ (zigAnalysis.types[errUnionObj.err]);
-                // let payloadHtml = typeValueName(errUnionObj.payload, wantHtml, wantSubLink, null);
-                // if (fnDecl != null && errSetTypeObj.fn === fnDecl.value.type) {
-                //     // function index parameter supplied and this is the inferred error set of it
-                //     return "!" + payloadHtml;
-                // } else {
-                //     return typeValueName(errUnionObj.err, wantHtml, wantSubLink, null) + "!" + payloadHtml;
-                // }
-            }
-            case typeKinds.Fn:
-            {
-                let fnObj = /** @type {Fn} */(typeObj);
-                let payloadHtml = "";
-                if (wantHtml) {
-                    payloadHtml += 'fn';
-                    if (fnDecl != null) {
-                        payloadHtml += ' ';
-                        if (linkFnNameDecl != null) {
-                            payloadHtml += '' +
-                                escapeHtml(fnDecl.name) + '';
-                        } else {
-                            payloadHtml += escapeHtml(fnDecl.name);
-                        }
-                        payloadHtml += '';
-                    }
-                } else {
-                    payloadHtml += 'fn'
-                }
-                payloadHtml += '(';
-                    if (fnObj.params) {
-                        let fields = null;
-                        let isVarArgs = false;
-                        let fnNode = zigAnalysis.astNodes[fnObj.src];
-                        fields = fnNode.fields;
-                        isVarArgs = fnNode.varArgs;
-
-                        for (let i = 0; i < fnObj.params.length; i += 1) {
-                            if (i != 0) {
-                                payloadHtml += ', ';
-                            }
-
-                            let value = fnObj.params[i];
-                            let paramValue = resolveValue(value);
-
-                            if (fields != null) {
-                                let paramNode = zigAnalysis.astNodes[fields[i]];
-
-                                if (paramNode.varArgs) {
-                                    payloadHtml += '...';
-                                    continue;
-                                }
-
-                                if (paramNode.noalias) {
-                                    if (wantHtml) {
-                                        payloadHtml += 'noalias ';
-                                    } else {
-                                        payloadHtml += 'noalias ';
-                                    }
-                                }
-
-                                if (paramNode.comptime) {
-                                    if (wantHtml) {
-                                        payloadHtml += 'comptime ';
-                                    } else {
-                                        payloadHtml += 'comptime ';
-                                    }
-                                }
-
-                                let paramName = paramNode.name;
-                                if (paramName != null) {
-                                    // skip if it matches the type name
-                                    if (!shouldSkipParamName(paramValue, paramName)) {
-                                        payloadHtml += paramName + ': ';
-                                    }
-                                }
-                            }
-
-                            if (isVarArgs && i === fnObj.params.length - 1) {
-                                payloadHtml += '...';
-                            } else if ("refPath" in value) {
-                                payloadHtml += '';
-                                payloadHtml += '[Ref Path]';
-                                payloadHtml += '';
-
-                            } else if ("type" in value) {
-                                let name = typeValueName(value, false, false, fnDecl, linkFnNameDecl);
-                                payloadHtml += '' + escapeHtml(name) + '';
-                            } else if ("comptimeExpr" in value) {
-                                payloadHtml += '[ComptimeExpr]';
-                            } else if (wantHtml) {
-                                payloadHtml += 'var';
-                            } else {
-                                payloadHtml += 'var';
-                            }
-                        }
-                    }
-
-                payloadHtml += ') ';
-                if (fnObj.ret != null) {
-                    payloadHtml += typeValueName(fnObj.ret, wantHtml, wantSubLink, fnDecl);
-                } else if (wantHtml) {
-                    payloadHtml += 'anytype';
-                } else {
-                    payloadHtml += 'anytype';
-                }
-                return payloadHtml;
-            }
-            default:
-                throw "TODO";
-                // if (wantHtml) {
-                //     return escapeHtml(typeObj.name);
-                // } else {
-                //     return typeObj.name;
-                // }
-        }
     }
 
     /** @param {Type} typeObj */
@@ -1607,25 +1654,25 @@ var zigAnalysis;
     /** @param {Decl} decl */
     function renderValue(decl) {
 
-        let declTypeRef = typeOfDecl(decl);
-        let declValueText = "";
-        switch(Object.keys(decl.value)[0]) {
-            case "int":
-                declValueText += /** @type {{int: {value: number}}} */(decl.value).int.value;
-                break;
-            case "float":
-                declValueText += /** @type {{float: {value: number}}} */(decl.value).float.value;
-                break;
-            case "comptimeExpr":
-                declValueText += "[ComptimeExpr]";
-                break;
-            default:
-                console.log("TODO: renderValue for ", Object.keys(decl.value)[0]);
-                declValueText += "#TODO#";
-        }
+        let declTypeRef = decl.value.typeRef;
+        let declValueText = exprName(decl.value.expr);
+//        switch(Object.keys(decl.value)[0]) {
+//            case "int":
+//                declValueText += /** @type {{int: {value: number}}} */(decl.value).int.value;
+//                break;
+//            case "float":
+//                declValueText += /** @type {{float: {value: number}}} */(decl.value).float.value;
+//                break;
+//            case "comptimeExpr":
+//                declValueText += "[ComptimeExpr]";
+//                break;
+//            default:
+//                console.log("TODO: renderValue for ", Object.keys(decl.value)[0]);
+//                declValueText += "#TODO#";
+//        }
 
         domFnProtoCode.innerHTML = 'const ' +
-            escapeHtml(decl.name) + ': ' + typeValueName(declTypeRef, true, true) +
+            escapeHtml(decl.name) + ': ' + exprName(declTypeRef, {wantHtml: true}) +
             " = " + declValueText;
 
         let docs = zigAnalysis.astNodes[decl.src].docs;
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 3ab334a0f3..de8cc3660d 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -17,13 +17,14 @@ files: std.AutoHashMapUnmanaged(*File, usize) = .{},
 calls: std.ArrayListUnmanaged(DocData.Call) = .{},
 types: std.ArrayListUnmanaged(DocData.Type) = .{},
 decls: std.ArrayListUnmanaged(DocData.Decl) = .{},
+exprs: std.ArrayListUnmanaged(DocData.Expr) = .{},
 ast_nodes: std.ArrayListUnmanaged(DocData.AstNode) = .{},
 comptime_exprs: std.ArrayListUnmanaged(DocData.ComptimeExpr) = .{},
 
 // These fields hold temporary state of the analysis process
 // and are mainly used by the decl path resolving algorithm.
 pending_ref_paths: std.AutoHashMapUnmanaged(
-    *DocData.WalkResult, // pointer to declpath tail end (ie `&decl_path[decl_path.len - 1]`)
+    *DocData.Expr, // pointer to declpath tail end (ie `&decl_path[decl_path.len - 1]`)
     std.ArrayListUnmanaged(RefPathResumeInfo),
 ) = .{},
 ref_paths_pending_on_decls: std.AutoHashMapUnmanaged(
@@ -37,7 +38,7 @@ ref_paths_pending_on_types: std.AutoHashMapUnmanaged(
 
 const RefPathResumeInfo = struct {
     file: *File,
-    ref_path: []DocData.WalkResult,
+    ref_path: []DocData.Expr,
 };
 
 var arena_allocator: std.heap.ArenaAllocator = undefined;
@@ -80,7 +81,6 @@ pub fn generateZirData(self: *Autodoc) !void {
             .ComptimeExpr = .{ .name = "ComptimeExpr" },
         });
 
-        var tr = DocData.WalkResult{ .type = @enumToInt(Ref.usize_type) };
         // this skipts Ref.none but it's ok becuse we replaced it with ComptimeExpr
         var i: u32 = 1;
         while (i <= @enumToInt(Ref.anyerror_void_error_union_type)) : (i += 1) {
@@ -96,7 +96,6 @@ pub fn generateZirData(self: *Autodoc) !void {
                             .Array = .{
                                 .len = .{
                                     .int = .{
-                                        .typeRef = &tr,
                                         .value = 1,
                                         .negated = false,
                                     },
@@ -163,7 +162,7 @@ pub fn generateZirData(self: *Autodoc) !void {
     var root_scope = Scope{ .parent = null, .enclosing_type = main_type_index };
     try self.ast_nodes.append(self.arena, .{ .name = "(root)" });
     try self.files.put(self.arena, file, main_type_index);
-    _ = try self.walkInstruction(file, &root_scope, Zir.main_struct_inst);
+    _ = try self.walkInstruction(file, &root_scope, Zir.main_struct_inst, false);
 
     if (self.ref_paths_pending_on_decls.count() > 0) {
         @panic("some decl paths were never fully analized (pending on decls)");
@@ -182,6 +181,7 @@ pub fn generateZirData(self: *Autodoc) !void {
         .calls = self.calls.items,
         .types = self.types.items,
         .decls = self.decls.items,
+        .exprs = self.exprs.items,
         .astNodes = self.ast_nodes.items,
         .comptimeExprs = self.comptime_exprs.items,
     };
@@ -305,11 +305,12 @@ const DocData = struct {
     },
     types: []Type,
     decls: []Decl,
+    exprs: []Expr,
     comptimeExprs: []ComptimeExpr,
     const Call = struct {
-        func: WalkResult,
-        args: []WalkResult,
-        ret: WalkResult,
+        func: Expr,
+        args: []Expr,
+        ret: Expr,
     };
 
     /// All the type "families" as described by `std.builtin.TypeId`
@@ -340,7 +341,6 @@ const DocData = struct {
 
     const ComptimeExpr = struct {
         code: []const u8,
-        typeRef: WalkResult,
     };
     const Package = struct {
         name: []const u8 = "root",
@@ -356,7 +356,6 @@ const DocData = struct {
         kind: []const u8,
         isTest: bool,
         src: usize, // index into astNodes
-        // typeRef: TypeRef,
         value: WalkResult,
         // The index in astNodes of the `test declname { }` node
         decltest: ?usize = null,
@@ -383,18 +382,18 @@ const DocData = struct {
         Float: struct { name: []const u8 },
         Pointer: struct {
             size: std.builtin.TypeInfo.Pointer.Size,
-            child: WalkResult,
+            child: Expr,
         },
         Array: struct {
-            len: WalkResult,
-            child: WalkResult,
+            len: Expr,
+            child: Expr,
         },
         Struct: struct {
             name: []const u8,
             src: usize, // index into astNodes
             privDecls: []usize = &.{}, // index into decls
             pubDecls: []usize = &.{}, // index into decls
-            fields: ?[]WalkResult = null, // (use src->fields to find names)
+            fields: ?[]Expr = null, // (use src->fields to find names)
         },
         ComptimeExpr: struct { name: []const u8 },
         ComptimeFloat: struct { name: []const u8 },
@@ -403,7 +402,7 @@ const DocData = struct {
         Null: struct { name: []const u8 },
         Optional: struct {
             name: []const u8,
-            child: WalkResult,
+            child: Expr,
         },
         ErrorUnion: struct { name: []const u8 },
         ErrorSet: struct {
@@ -423,13 +422,13 @@ const DocData = struct {
             src: usize, // index into astNodes
             privDecls: []usize = &.{}, // index into decls
             pubDecls: []usize = &.{}, // index into decls
-            fields: []WalkResult = &.{}, // (use src->fields to find names)
+            fields: []Expr = &.{}, // (use src->fields to find names)
         },
         Fn: struct {
             name: []const u8,
             src: ?usize = null, // index into astNodes
-            ret: WalkResult,
-            params: ?[]WalkResult = null, // (use src->fields to find names)
+            ret: Expr,
+            params: ?[]Expr = null, // (use src->fields to find names)
         },
         BoundFn: struct { name: []const u8 },
         Opaque: struct { name: []const u8 },
@@ -517,75 +516,61 @@ const DocData = struct {
         }
     };
 
-    /// A WalkResult represents the result of the analysis process done to a
-    /// declaration. This includes: decls, fields, etc.
-    ///
-    /// The data in WalkResult is mostly normalized, which means that a
-    /// WalkResult that results in a type definition will hold an index into
-    /// `self.types`.
-    const WalkResult = union(enum) {
+    /// An Expr represents the (untyped) result of analizing instructions.
+    /// The data is normalized, which means that an Expr that results in a
+    /// type definition will hold an index into `self.types`.
+    pub const Expr = union(enum) {
         comptimeExpr: usize, // index in `comptimeExprs`
         void,
         @"unreachable",
-        @"null": *WalkResult,
-        @"undefined": *WalkResult,
-        @"struct": Struct,
+        @"null",
+        @"undefined",
+        @"struct": []FieldVal,
         bool: bool,
         @"anytype",
         type: usize, // index in `types`
         this: usize, // index in `types`
         declRef: usize, // index in `decls`
         fieldRef: FieldRef,
-        refPath: []WalkResult,
+        refPath: []Expr,
         int: struct {
-            typeRef: *WalkResult,
             value: usize, // direct value
             negated: bool = false,
         },
-        float: struct {
-            typeRef: *WalkResult,
-            value: f64, // direct value
-            negated: bool = false,
-        },
-        array: Array,
+        float: f64, // direct value
+        array: []usize, // index in `exprs`
         call: usize, // index in `calls`
-        enumLiteral: []const u8,
-        typeOf: *WalkResult,
-        sizeOf: *WalkResult,
+        enumLiteral: []const u8, // direct value
+        typeOf: usize, // index in `exprs`
+        as: struct {
+            typeRefArg: ?usize, // index in `exprs`
+            exprArg: usize, // index in `exprs`
+        },
+        sizeOf: usize, // index in `exprs`
         compileError: []const u8,
-        string: []const u8,
-
+        string: []const u8, // direct value
         const FieldRef = struct {
             type: usize, // index in `types`
             index: usize, // index in type.fields
         };
 
-        const Struct = struct {
-            typeRef: *WalkResult,
-            fieldVals: []FieldVal,
-
-            const FieldVal = struct {
-                name: []const u8,
-                val: WalkResult,
-            };
-        };
-        const Array = struct {
-            typeRef: *WalkResult,
-            data: []WalkResult,
+        const FieldVal = struct {
+            name: []const u8,
+            val: WalkResult,
         };
 
         pub fn jsonStringify(
-            self: WalkResult,
+            self: Expr,
             options: std.json.StringifyOptions,
             w: anytype,
         ) std.os.WriteError!void {
             switch (self) {
-                .void, .@"unreachable", .@"anytype" => {
+                .void, .@"unreachable", .@"anytype", .@"null", .@"undefined" => {
                     try w.print(
                         \\{{ "{s}":{{}} }}
                     , .{@tagName(self)});
                 },
-                .type, .comptimeExpr, .call, .this, .declRef => |v| {
+                .type, .comptimeExpr, .call, .this, .declRef, .typeOf => |v| {
                     try w.print(
                         \\{{ "{s}":{} }}
                     , .{ @tagName(self), v });
@@ -593,43 +578,28 @@ const DocData = struct {
                 .int => |v| {
                     const neg = if (v.negated) "-" else "";
                     try w.print(
-                        \\{{ "int": {{ "typeRef":
-                    , .{});
-                    try v.typeRef.jsonStringify(options, w);
-                    try w.print(
-                        \\, "value": {s}{} }} }}
+                        \\{{ "int": {s}{} }}
                     , .{ neg, v.value });
                 },
                 .float => |v| {
-                    const neg = if (v.negated) "-" else "";
                     try w.print(
-                        \\{{ "float": {{ "typeRef":
-                    , .{});
-                    try v.typeRef.jsonStringify(options, w);
-                    try w.print(
-                        \\, "value": {s}1 }} }}
-                    , .{neg});
-                    // TODO: uncomment once float panic is fixed in stdlib
-                    //       See: https://github.com/ziglang/zig/issues/11283
-                    // try w.print(
-                    //     \\, "value": {s}{e} }} }}
-                    // , .{ neg, v.value });
+                        \\{{ "float": {} }}
+                    , .{v});
                 },
                 .bool => |v| {
                     try w.print(
                         \\{{ "bool":{} }}
                     , .{v});
                 },
-                .@"undefined" => |v| try std.json.stringify(v, options, w),
-                .@"null" => |v| try std.json.stringify(v, options, w),
-                .typeOf, .sizeOf => |v| try std.json.stringify(v, options, w),
+                .sizeOf => |v| try std.json.stringify(v, options, w),
+                .as => |v| try std.json.stringify(v, options, w),
                 .fieldRef => |v| try std.json.stringify(
                     struct { fieldRef: FieldRef }{ .fieldRef = v },
                     options,
                     w,
                 ),
                 .@"struct" => |v| try std.json.stringify(
-                    struct { @"struct": Struct }{ .@"struct" = v },
+                    struct { @"struct": []FieldVal }{ .@"struct" = v },
                     options,
                     w,
                 ),
@@ -642,7 +612,7 @@ const DocData = struct {
                     }
                 },
                 .array => |v| try std.json.stringify(
-                    struct { @"array": Array }{ .@"array" = v },
+                    struct { @"array": []usize }{ .@"array" = v },
                     options,
                     w,
                 ),
@@ -677,6 +647,17 @@ const DocData = struct {
             }
         }
     };
+
+    /// A WalkResult represents the result of the analysis process done to a
+    /// a Zir instruction. Walk results carry type information either inferred
+    /// from the context (eg string literals are pointers to null-terminated
+    /// arrays), or because of @as() instructions.
+    /// Since the type information is only needed in certain contexts, the
+    /// underlying normalized data (Expr) is untyped.
+    const WalkResult = struct {
+        typeRef: ?Expr = null, // index in `exprs`
+        expr: Expr, // index in `exprs`
+    };
 };
 
 /// Called when we need to analyze a Zir instruction.
@@ -692,6 +673,7 @@ fn walkInstruction(
     file: *File,
     parent_scope: *Scope,
     inst_index: usize,
+    need_type: bool, // true if the caller needs us to provide also a typeRef
 ) error{OutOfMemory}!DocData.WalkResult {
     const tags = file.zir.instructions.items(.tag);
     const data = file.zir.instructions.items(.data);
@@ -711,11 +693,11 @@ fn walkInstruction(
         },
         .closure_get => {
             const inst_node = data[inst_index].inst_node;
-            return try self.walkInstruction(file, parent_scope, inst_node.inst);
+            return try self.walkInstruction(file, parent_scope, inst_node.inst, need_type);
         },
         .closure_capture => {
             const un_tok = data[inst_index].un_tok;
-            return try self.walkRef(file, parent_scope, un_tok.operand);
+            return try self.walkRef(file, parent_scope, un_tok.operand, need_type);
         },
         .import => {
             const str_tok = data[inst_index].str_tok;
@@ -726,17 +708,20 @@ fn walkInstruction(
                 const cte_slot_index = self.comptime_exprs.items.len;
                 try self.comptime_exprs.append(self.arena, .{
                     .code = path,
-                    .typeRef = .{ .type = @enumToInt(DocData.DocTypeKinds.Type) },
                 });
                 return DocData.WalkResult{
-                    .comptimeExpr = cte_slot_index,
+                    .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                    .expr = .{ .comptimeExpr = cte_slot_index },
                 };
             }
 
             const new_file = self.module.importFile(file, path) catch unreachable;
             const result = try self.files.getOrPut(self.arena, new_file.file);
             if (result.found_existing) {
-                return DocData.WalkResult{ .type = result.value_ptr.* };
+                return DocData.WalkResult{
+                    .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                    .expr = .{ .type = result.value_ptr.* },
+                };
             }
 
             result.value_ptr.* = self.types.items.len;
@@ -745,18 +730,38 @@ fn walkInstruction(
                 .parent = null,
                 .enclosing_type = self.types.items.len,
             };
-            const new_file_walk_result = self.walkInstruction(
+
+            return self.walkInstruction(
                 new_file.file,
                 &new_scope,
                 Zir.main_struct_inst,
+                need_type,
             );
-
-            return new_file_walk_result;
         },
         .str => {
-            const str = data[inst_index].str;
+            const str = data[inst_index].str.get(file.zir);
+
+            const tRef: ?DocData.Expr = if (!need_type) null else blk: {
+                const arrTypeId = self.types.items.len;
+                try self.types.append(self.arena, .{
+                    .Array = .{
+                        .len = .{ .int = .{ .value = str.len } },
+                        .child = .{ .type = @enumToInt(Ref.u8_type) },
+                    },
+                });
+                const ptrTypeId = self.types.items.len;
+                try self.types.append(self.arena, .{
+                    .Pointer = .{
+                        .size = .One,
+                        .child = .{ .type = arrTypeId },
+                        // TODO: add sentinel!
+                    },
+                });
+                break :blk .{ .type = ptrTypeId };
+            };
             return DocData.WalkResult{
-                .string = str.get(file.zir),
+                .typeRef = tRef,
+                .expr = .{ .string = str },
             };
         },
         .compile_error => {
@@ -765,24 +770,23 @@ fn walkInstruction(
                 file,
                 parent_scope,
                 un_node.operand,
+                false,
             );
 
-            return DocData.WalkResult{ .compileError = operand.string };
+            return DocData.WalkResult{
+                .expr = .{ .compileError = operand.expr.string },
+            };
         },
         .enum_literal => {
             const str_tok = data[inst_index].str_tok;
             const literal = file.zir.nullTerminatedString(str_tok.start);
-            return DocData.WalkResult{ .enumLiteral = literal };
+            return DocData.WalkResult{ .expr = .{ .enumLiteral = literal } };
         },
         .int => {
             const int = data[inst_index].int;
-            const t = try self.arena.create(DocData.WalkResult);
-            t.* = .{ .type = @enumToInt(Ref.comptime_int_type) };
             return DocData.WalkResult{
-                .int = .{
-                    .typeRef = t,
-                    .value = int,
-                },
+                .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+                .expr = .{ .int = .{ .value = int } },
             };
         },
         .error_union_type => {
@@ -790,20 +794,23 @@ fn walkInstruction(
             const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
 
             // TODO: return the actual error union instread of cheating
-            return self.walkRef(file, parent_scope, extra.data.rhs);
+            return self.walkRef(file, parent_scope, extra.data.rhs, need_type);
         },
         .ptr_type_simple => {
             const ptr = data[inst_index].ptr_type_simple;
             const type_slot_index = self.types.items.len;
-            const elem_type_ref = try self.walkRef(file, parent_scope, ptr.elem_type);
+            const elem_type_ref = try self.walkRef(file, parent_scope, ptr.elem_type, false);
             try self.types.append(self.arena, .{
                 .Pointer = .{
                     .size = ptr.size,
-                    .child = elem_type_ref,
+                    .child = elem_type_ref.expr,
                 },
             });
 
-            return DocData.WalkResult{ .type = type_slot_index };
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .type = type_slot_index },
+            };
         },
         .ptr_type => {
             const ptr = data[inst_index].ptr_type;
@@ -814,74 +821,84 @@ fn walkInstruction(
                 file,
                 parent_scope,
                 extra.data.elem_type,
+                false,
             );
             try self.types.append(self.arena, .{
                 .Pointer = .{
                     .size = ptr.size,
-                    .child = elem_type_ref,
+                    .child = elem_type_ref.expr,
                 },
             });
-
-            return DocData.WalkResult{ .type = type_slot_index };
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .type = type_slot_index },
+            };
         },
         .array_type => {
             const bin = data[inst_index].bin;
-            const len = try self.walkRef(file, parent_scope, bin.lhs);
-            const child = try self.walkRef(file, parent_scope, bin.rhs);
+            const len = try self.walkRef(file, parent_scope, bin.lhs, false);
+            const child = try self.walkRef(file, parent_scope, bin.rhs, false);
 
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
                 .Array = .{
-                    .len = len,
-                    .child = child,
+                    .len = len.expr,
+                    .child = child.expr,
                 },
             });
-            return DocData.WalkResult{ .type = type_slot_index };
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .type = type_slot_index },
+            };
         },
         .array_init => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.MultiOp, pl_node.payload_index);
             const operands = file.zir.refSlice(extra.end, extra.data.operands_len);
-            const array_data = try self.arena.alloc(DocData.WalkResult, operands.len);
-            for (operands) |op, idx| {
-                array_data[idx] = try self.walkRef(file, parent_scope, op);
-            }
+            const array_data = try self.arena.alloc(usize, operands.len);
 
-            const at = try self.arena.create(DocData.WalkResult);
-            at.* = .{ .type = @enumToInt(Ref.usize_type) };
+            // TODO: make sure that you want the array to be fully normalized for real
+            // then update this code to conform to your choice.
+
+            var array_type: ?DocData.Expr = null;
+            for (operands) |op, idx| {
+                // we only ask to figure out type info for the first element
+                // as it will be used later on to find out the array type!
+                const wr = try self.walkRef(file, parent_scope, op, idx == 0);
+
+                if (idx == 0) {
+                    array_type = wr.typeRef;
+                }
+
+                // We know that Zir wraps every operand in an @as expression
+                // so we want to peel it away and only save the target type
+                // once, since we need it later to define the array type.
+                array_data[idx] = wr.expr.as.exprArg;
+            }
 
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
                 .Array = .{
                     .len = .{
                         .int = .{
-                            .typeRef = at,
                             .value = operands.len,
                             .negated = false,
                         },
                     },
-                    .child = try self.typeOfWalkResult(array_data[0]),
+                    .child = array_type.?,
                 },
             });
 
-            const t = try self.arena.create(DocData.WalkResult);
-            t.* = .{ .type = type_slot_index };
-            return DocData.WalkResult{ .array = .{
-                .typeRef = t,
-                .data = array_data,
-            } };
+            return DocData.WalkResult{
+                .typeRef = .{ .type = type_slot_index },
+                .expr = .{ .array = array_data },
+            };
         },
         .float => {
             const float = data[inst_index].float;
-
-            const t = try self.arena.create(DocData.WalkResult);
-            t.* = .{ .type = @enumToInt(Ref.comptime_float_type) };
-
             return DocData.WalkResult{
-                .float = .{
-                    .typeRef = t,
-                    .value = float,
-                },
+                .typeRef = .{ .type = @enumToInt(Ref.comptime_float_type) },
+                .expr = .{ .float = float },
             };
         },
         .negate => {
@@ -890,8 +907,9 @@ fn walkInstruction(
                 file,
                 parent_scope,
                 un_node.operand,
+                need_type,
             );
-            switch (operand) {
+            switch (operand.expr) {
                 .int => |*int| int.negated = true,
                 else => {
                     printWithContext(
@@ -906,75 +924,93 @@ fn walkInstruction(
         },
         .size_of => {
             const un_node = data[inst_index].un_node;
-            var operand = try self.arena.create(DocData.WalkResult);
-            operand.* = try self.walkRef(
+            const operand = try self.walkRef(
                 file,
                 parent_scope,
                 un_node.operand,
+                false,
             );
-            return DocData.WalkResult{ .sizeOf = operand };
+            const operand_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, operand.expr);
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+                .expr = .{ .sizeOf = operand_index },
+            };
         },
 
         .typeof => {
             const un_node = data[inst_index].un_node;
-            var operand = try self.arena.create(DocData.WalkResult);
-            operand.* = try self.walkRef(
+            const operand = try self.walkRef(
                 file,
                 parent_scope,
                 un_node.operand,
+                need_type,
             );
-            return DocData.WalkResult{ .typeOf = operand };
+            const operand_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, operand.expr);
+
+            return DocData.WalkResult{
+                .typeRef = operand.typeRef,
+                .expr = .{ .typeOf = operand_index },
+            };
         },
         .as_node => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.As, pl_node.payload_index);
-            const dest_type_walk = try self.walkRef(file, parent_scope, extra.data.dest_type);
-            const dest_type_ref = dest_type_walk;
+            const dest_type_walk = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.dest_type,
+                false,
+            );
 
-            var operand = try self.walkRef(file, parent_scope, extra.data.operand);
+            const operand = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.operand,
+                false,
+            );
+            const operand_idx = self.exprs.items.len;
+            try self.exprs.append(self.arena, operand.expr);
 
-            switch (operand) {
-                else => printWithContext(
-                    file,
-                    inst_index,
-                    "TODO: handle {s} in `walkInstruction.as_node`",
-                    .{@tagName(operand)},
-                ),
-                .declRef, .refPath, .type, .string, .call, .enumLiteral => {},
-                // we don't do anything because up until now,
-                // I've only seen this used as such:
-                //       @as(@as(type, Baz), .{})
-                // and we don't want to toss away the
-                // decl_val information (eg by replacing it with
-                // a WalkResult.type).
-                .comptimeExpr => {
-                    self.comptime_exprs.items[operand.comptimeExpr].typeRef = dest_type_ref;
+            const dest_type_idx = self.exprs.items.len;
+            try self.exprs.append(self.arena, dest_type_walk.expr);
+
+            // TODO: there's something wrong with how both `as` and `WalkrResult`
+            //       try to store type information.
+            return DocData.WalkResult{
+                .typeRef = dest_type_walk.expr,
+                .expr = .{
+                    .as = .{
+                        .typeRefArg = dest_type_idx,
+                        .exprArg = operand_idx,
+                    },
                 },
-                .int => operand.int.typeRef.* = dest_type_ref,
-                .@"struct" => operand.@"struct".typeRef.* = dest_type_ref,
-                .@"undefined" => operand.@"undefined".* = dest_type_ref,
-            }
-
-            return operand;
+            };
         },
         .optional_type => {
             const un_node = data[inst_index].un_node;
-            var operand: DocData.WalkResult = try self.walkRef(
+            const operand: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
                 un_node.operand,
+                false,
             );
-            const type_ref = operand;
-            const res = DocData.WalkResult{ .type = self.types.items.len };
+
+            const operand_idx = self.types.items.len;
             try self.types.append(self.arena, .{
-                .Optional = .{ .name = "?TODO", .child = type_ref },
+                .Optional = .{ .name = "?TODO", .child = operand.expr },
             });
-            return res;
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .type = operand_idx },
+            };
         },
         .decl_val, .decl_ref => {
             const str_tok = data[inst_index].str_tok;
             const decls_slot_index = parent_scope.resolveDeclName(str_tok.start);
-            return DocData.WalkResult{ .declRef = decls_slot_index };
+            return DocData.WalkResult{ .expr = .{ .declRef = decls_slot_index } };
         },
         .field_val, .field_call_bind, .field_ptr, .field_type => {
             // TODO: field type uses Zir.Inst.FieldType, it just happens to have the
@@ -982,7 +1018,7 @@ fn walkInstruction(
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Field, pl_node.payload_index);
 
-            var path: std.ArrayListUnmanaged(DocData.WalkResult) = .{};
+            var path: std.ArrayListUnmanaged(DocData.Expr) = .{};
             var lhs = @enumToInt(extra.data.lhs) - Ref.typed_value_map.len; // underflow = need to handle Refs
 
             try path.append(self.arena, .{
@@ -1006,12 +1042,13 @@ fn walkInstruction(
                 lhs = @enumToInt(lhs_extra.data.lhs) - Ref.typed_value_map.len; // underflow = need to handle Refs
             }
 
-            const wr = try self.walkInstruction(file, parent_scope, lhs);
-            try path.append(self.arena, wr);
+            // TODO: double check that we really don't need type info here
+            const wr = try self.walkInstruction(file, parent_scope, lhs, false);
+            try path.append(self.arena, wr.expr);
 
             // This way the data in `path` has the same ordering that the ref
             // path has in the text: most general component first.
-            std.mem.reverse(DocData.WalkResult, path.items);
+            std.mem.reverse(DocData.Expr, path.items);
 
             // Righ now, every element of `path` is a string except its first
             // element (at index 0). We're now going to attempt to resolve each
@@ -1026,7 +1063,7 @@ fn walkInstruction(
             //       any value that depends on that will have to become a
             //       comptimeExpr.
             try self.tryResolveRefPath(file, lhs, path.items);
-            return DocData.WalkResult{ .refPath = path.items };
+            return DocData.WalkResult{ .expr = .{ .refPath = path.items } };
         },
         .int_type => {
             const int_type = data[inst_index].int_type;
@@ -1037,28 +1074,37 @@ fn walkInstruction(
             try self.types.append(self.arena, .{
                 .Int = .{ .name = name },
             });
-            return DocData.WalkResult{ .type = self.types.items.len - 1 };
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .type = self.types.items.len - 1 },
+            };
         },
         .block => {
-            const res = DocData.WalkResult{ .comptimeExpr = self.comptime_exprs.items.len };
+            const res = DocData.WalkResult{ .expr = .{
+                .comptimeExpr = self.comptime_exprs.items.len,
+            } };
             try self.comptime_exprs.append(self.arena, .{
                 .code = "if(banana) 1 else 0",
-                .typeRef = .{ .type = 0 },
             });
             return res;
         },
         .block_inline => {
-            return self.walkRef(file, parent_scope, getBlockInlineBreak(file.zir, inst_index));
+            return self.walkRef(
+                file,
+                parent_scope,
+                getBlockInlineBreak(file.zir, inst_index),
+                need_type,
+            );
         },
         .struct_init => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.StructInit, pl_node.payload_index);
             const field_vals = try self.arena.alloc(
-                DocData.WalkResult.Struct.FieldVal,
+                DocData.Expr.FieldVal,
                 extra.data.fields_len,
             );
 
-            const type_ref = try self.arena.create(DocData.WalkResult);
+            var type_ref: DocData.Expr = undefined;
             var idx = extra.end;
             for (field_vals) |*fv| {
                 const init_extra = file.zir.extraData(Zir.Inst.StructInit.Item, idx);
@@ -1079,19 +1125,25 @@ fn walkInstruction(
                             file,
                             parent_scope,
                             field_extra.data.container_type,
+                            false,
                         );
-                        type_ref.* = wr;
+                        type_ref = wr.expr;
                     }
                     break :blk file.zir.nullTerminatedString(field_extra.data.name_start);
                 };
-                const value = try self.walkRef(file, parent_scope, init_extra.data.init);
+                const value = try self.walkRef(
+                    file,
+                    parent_scope,
+                    init_extra.data.init,
+                    need_type,
+                );
                 fv.* = .{ .name = field_name, .val = value };
             }
 
-            return DocData.WalkResult{ .@"struct" = .{
+            return DocData.WalkResult{
                 .typeRef = type_ref,
-                .fieldVals = field_vals,
-            } };
+                .expr = .{ .@"struct" = field_vals },
+            };
         },
         .error_set_decl => {
             const pl_node = data[inst_index].pl_node;
@@ -1122,7 +1174,10 @@ fn walkInstruction(
                 },
             });
 
-            return DocData.WalkResult{ .type = type_slot_index };
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .type = type_slot_index },
+            };
         },
         .param_anytype => {
             // Analysis of anytype function params happens in `.func`.
@@ -1134,9 +1189,8 @@ fn walkInstruction(
             const cte_slot_index = self.comptime_exprs.items.len;
             try self.comptime_exprs.append(self.arena, .{
                 .code = name,
-                .typeRef = .{ .type = @enumToInt(DocData.DocTypeKinds.ComptimeExpr) },
             });
-            return DocData.WalkResult{ .comptimeExpr = cte_slot_index };
+            return DocData.WalkResult{ .expr = .{ .comptimeExpr = cte_slot_index } };
         },
         .param, .param_comptime => {
             // See .param_anytype for more information.
@@ -1146,41 +1200,46 @@ fn walkInstruction(
             const cte_slot_index = self.comptime_exprs.items.len;
             try self.comptime_exprs.append(self.arena, .{
                 .code = name,
-                .typeRef = .{ .type = @enumToInt(DocData.DocTypeKinds.ComptimeExpr) },
             });
-            return DocData.WalkResult{ .comptimeExpr = cte_slot_index };
+            return DocData.WalkResult{ .expr = .{ .comptimeExpr = cte_slot_index } };
         },
         .call => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Call, pl_node.payload_index);
 
-            const callee = try self.walkRef(file, parent_scope, extra.data.callee);
+            const callee = try self.walkRef(file, parent_scope, extra.data.callee, need_type);
 
             const args_len = extra.data.flags.args_len;
-            var args = try self.arena.alloc(DocData.WalkResult, args_len);
+            var args = try self.arena.alloc(DocData.Expr, args_len);
             const arg_refs = file.zir.refSlice(extra.end, args_len);
             for (arg_refs) |ref, idx| {
-                args[idx] = try self.walkRef(file, parent_scope, ref);
+                // TODO: consider toggling need_type to true if we ever want
+                //       to show discrepancies between the types of provided
+                //       arguments and the types declared in the function
+                //       signature for its parameters.
+                const wr = try self.walkRef(file, parent_scope, ref, false);
+                args[idx] = wr.expr;
             }
 
-            // TODO: see if we can ever do something better than just always
-            //       resolve function calls to a comptimeExpr.
             const cte_slot_index = self.comptime_exprs.items.len;
             try self.comptime_exprs.append(self.arena, .{
                 .code = "func call",
-                .typeRef = .{
-                    .type = @enumToInt(DocData.DocTypeKinds.ComptimeExpr),
-                }, // TODO: extract return type from callee when available
             });
 
             const call_slot_index = self.calls.items.len;
             try self.calls.append(self.arena, .{
-                .func = callee,
+                .func = callee.expr,
                 .args = args,
                 .ret = .{ .comptimeExpr = cte_slot_index },
             });
 
-            return DocData.WalkResult{ .call = call_slot_index };
+            return DocData.WalkResult{
+                .typeRef = if (callee.typeRef) |tr| switch (tr) {
+                    .type => |func_type_idx| self.types.items[func_type_idx].Fn.ret,
+                    else => null,
+                } else null,
+                .expr = .{ .call = call_slot_index },
+            };
         },
         .func, .func_inferred => {
             const type_slot_index = self.types.items.len;
@@ -1208,42 +1267,13 @@ fn walkInstruction(
                 },
 
                 .opaque_decl => return self.cteTodo("opaque {...}"),
-                //                .func => {
-                //                    const type_slot_index = self.types.items.len;
-                //                    try self.types.append(self.arena, .{ .Unanalyzed = {} });
-                //
-                //                    const result = try self.analyzeFunction(
-                //                        file,
-                //                        parent_scope,
-                //                        inst_index,
-                //                        self_ast_node_index,
-                //                        type_slot_index,
-                //                    );
-                //                    if (self.ref_paths_pending_on_types.get(type_slot_index)) |paths| {
-                //                        for (paths.items) |resume_info| {
-                //                            try self.tryResolveRefPath(
-                //                                resume_info.file,
-                //                                inst_index,
-                //                                resume_info.ref_path,
-                //                            );
-                //                        }
-                //
-                //                        _ = self.ref_paths_pending_on_types.remove(type_slot_index);
-                //                        // TODO: we should deallocate the arraylist that holds all the
-                //                        //       decl paths. not doing it now since it's arena-allocated
-                //                        //       anyway, but maybe we should put it elsewhere.
-                //                    }
-                //                    return result;
-                //                },
                 .variable => {
                     const small = @bitCast(Zir.Inst.ExtendedVar.Small, extended.small);
                     var extra_index: usize = extended.operand;
                     if (small.has_lib_name) extra_index += 1;
                     if (small.has_align) extra_index += 1;
 
-                    const value: DocData.WalkResult =
-                        if (small.has_init)
-                    .{ .void = {} } else .{ .void = {} };
+                    const value: DocData.WalkResult = if (small.has_init) .{ .expr = .{ .void = {} } } else .{ .expr = .{ .void = {} } };
 
                     return value;
                 },
@@ -1322,10 +1352,9 @@ fn walkInstruction(
                         extra_index,
                     );
 
-                    // const body = file.zir.extra[extra_index..][0..body_len];
                     extra_index += body_len;
 
-                    var field_type_refs = try std.ArrayListUnmanaged(DocData.WalkResult).initCapacity(
+                    var field_type_refs = try std.ArrayListUnmanaged(DocData.Expr).initCapacity(
                         self.arena,
                         fields_len,
                     );
@@ -1369,7 +1398,10 @@ fn walkInstruction(
                         //       anyway, but maybe we should put it elsewhere.
                     }
 
-                    return DocData.WalkResult{ .type = type_slot_index };
+                    return DocData.WalkResult{
+                        .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                        .expr = .{ .type = type_slot_index },
+                    };
                 },
                 .enum_decl => {
                     const type_slot_index = self.types.items.len;
@@ -1516,8 +1548,10 @@ fn walkInstruction(
                         //       decl paths. not doing it now since it's arena-allocated
                         //       anyway, but maybe we should put it elsewhere.
                     }
-
-                    return DocData.WalkResult{ .type = type_slot_index };
+                    return DocData.WalkResult{
+                        .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                        .expr = .{ .type = type_slot_index },
+                    };
                 },
                 .struct_decl => {
                     const type_slot_index = self.types.items.len;
@@ -1590,7 +1624,7 @@ fn walkInstruction(
                     // const body = file.zir.extra[extra_index..][0..body_len];
                     extra_index += body_len;
 
-                    var field_type_refs: std.ArrayListUnmanaged(DocData.WalkResult) = .{};
+                    var field_type_refs: std.ArrayListUnmanaged(DocData.Expr) = .{};
                     var field_name_indexes: std.ArrayListUnmanaged(usize) = .{};
                     try self.collectStructFieldInfo(
                         file,
@@ -1626,11 +1660,16 @@ fn walkInstruction(
                         //       decl paths. not doing it now since it's arena-allocated
                         //       anyway, but maybe we should put it elsewhere.
                     }
-
-                    return DocData.WalkResult{ .type = type_slot_index };
+                    return DocData.WalkResult{
+                        .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                        .expr = .{ .type = type_slot_index },
+                    };
                 },
                 .this => {
-                    return DocData.WalkResult{ .this = parent_scope.enclosing_type };
+                    return DocData.WalkResult{
+                        .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                        .expr = .{ .this = parent_scope.enclosing_type },
+                    };
                 },
             }
         },
@@ -1793,7 +1832,7 @@ fn walkDecls(
                     .name = "test",
                     .isTest = true,
                     .src = ast_node_index,
-                    .value = .{ .type = 0 },
+                    .value = .{ .expr = .{ .type = 0 } },
                     .kind = "const",
                 };
                 continue;
@@ -1827,9 +1866,9 @@ fn walkDecls(
         };
 
         const walk_result = if (is_test) // TODO: decide if tests should show up at all
-            DocData.WalkResult{ .void = {} }
+            DocData.WalkResult{ .expr = .{ .void = {} } }
         else
-            try self.walkInstruction(file, scope, value_index);
+            try self.walkInstruction(file, scope, value_index, true);
 
         if (is_pub) {
             try decl_indexes.append(self.arena, decls_slot_index);
@@ -1857,7 +1896,7 @@ fn walkDecls(
             .name = name,
             .isTest = is_test,
             .src = ast_node_index,
-            // .typeRef = decl_type_ref,
+            //.typeRef = decl_type_ref,
             .value = walk_result,
             .kind = "const", // find where this information can be found
         };
@@ -1906,7 +1945,7 @@ fn tryResolveRefPath(
     /// File from which the decl path originates.
     file: *File,
     inst_index: usize, // used only for panicWithContext
-    path: []DocData.WalkResult,
+    path: []DocData.Expr,
 ) error{OutOfMemory}!void {
     var i: usize = 0;
     outer: while (i < path.len - 1) : (i += 1) {
@@ -1922,7 +1961,7 @@ fn tryResolveRefPath(
                 .declRef => |decl_index| {
                     const decl = self.decls.items[decl_index];
                     if (decl._analyzed) {
-                        resolved_parent = decl.value;
+                        resolved_parent = decl.value.expr;
                         continue;
                     }
 
@@ -2004,7 +2043,7 @@ fn tryResolveRefPath(
                     "TODO: handle `{s}`in tryResolveRefPath\nInfo: {}",
                     .{ @tagName(resolved_parent), resolved_parent },
                 );
-                path[i + 1] = try self.cteTodo("match failure");
+                path[i + 1] = (try self.cteTodo("match failure")).expr;
                 continue :outer;
             },
             .comptimeExpr, .call => {
@@ -2088,7 +2127,7 @@ fn tryResolveRefPath(
                         .{child_string},
                     );
 
-                    path[i + 1] = try self.cteTodo("match failure");
+                    path[i + 1] = (try self.cteTodo("match failure")).expr;
                     continue :outer;
                 },
                 .Union => |t_union| {
@@ -2134,7 +2173,7 @@ fn tryResolveRefPath(
                         "failed to match `{s}` in union",
                         .{child_string},
                     );
-                    path[i + 1] = try self.cteTodo("match failure");
+                    path[i + 1] = (try self.cteTodo("match failure")).expr;
                     continue :outer;
                 },
 
@@ -2181,7 +2220,7 @@ fn tryResolveRefPath(
                         "failed to match `{s}` in struct",
                         .{child_string},
                     );
-                    path[i + 1] = try self.cteTodo("match failure");
+                    path[i + 1] = (try self.cteTodo("match failure")).expr;
                     continue :outer;
                 },
             },
@@ -2214,7 +2253,7 @@ fn analyzeFunction(
     const fn_info = file.zir.getFnInfo(@intCast(u32, inst_index));
 
     try self.ast_nodes.ensureUnusedCapacity(self.arena, fn_info.total_params_len);
-    var param_type_refs = try std.ArrayListUnmanaged(DocData.WalkResult).initCapacity(
+    var param_type_refs = try std.ArrayListUnmanaged(DocData.Expr).initCapacity(
         self.arena,
         fn_info.total_params_len,
     );
@@ -2246,7 +2285,7 @@ fn analyzeFunction(
                 });
 
                 param_type_refs.appendAssumeCapacity(
-                    DocData.WalkResult{ .@"anytype" = {} },
+                    DocData.Expr{ .@"anytype" = {} },
                 );
             },
             .param, .param_comptime => {
@@ -2267,9 +2306,9 @@ fn analyzeFunction(
 
                 const break_index = file.zir.extra[extra.end..][extra.data.body_len - 1];
                 const break_operand = data[break_index].@"break".operand;
-                const param_type_ref = try self.walkRef(file, scope, break_operand);
+                const param_type_ref = try self.walkRef(file, scope, break_operand, false);
 
-                param_type_refs.appendAssumeCapacity(param_type_ref);
+                param_type_refs.appendAssumeCapacity(param_type_ref.expr);
             },
         }
     }
@@ -2278,7 +2317,7 @@ fn analyzeFunction(
     const ret_type_ref = blk: {
         const last_instr_index = fn_info.ret_ty_body[fn_info.ret_ty_body.len - 1];
         const break_operand = data[last_instr_index].@"break".operand;
-        const wr = try self.walkRef(file, scope, break_operand);
+        const wr = try self.walkRef(file, scope, break_operand, false);
         break :blk wr;
     };
 
@@ -2288,10 +2327,13 @@ fn analyzeFunction(
             .name = "todo_name func",
             .src = self_ast_node_index,
             .params = param_type_refs.items,
-            .ret = ret_type_ref,
+            .ret = ret_type_ref.expr,
         },
     };
-    return DocData.WalkResult{ .type = type_slot_index };
+    return DocData.WalkResult{
+        .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+        .expr = .{ .type = type_slot_index },
+    };
 }
 
 fn collectUnionFieldInfo(
@@ -2299,7 +2341,7 @@ fn collectUnionFieldInfo(
     file: *File,
     scope: *Scope,
     fields_len: usize,
-    field_type_refs: *std.ArrayListUnmanaged(DocData.WalkResult),
+    field_type_refs: *std.ArrayListUnmanaged(DocData.Expr),
     field_name_indexes: *std.ArrayListUnmanaged(usize),
     ei: usize,
 ) !void {
@@ -2344,8 +2386,8 @@ fn collectUnionFieldInfo(
 
         // type
         {
-            const walk_result = try self.walkRef(file, scope, field_type);
-            try field_type_refs.append(self.arena, walk_result);
+            const walk_result = try self.walkRef(file, scope, field_type, false);
+            try field_type_refs.append(self.arena, walk_result.expr);
         }
 
         // ast node
@@ -2368,7 +2410,7 @@ fn collectStructFieldInfo(
     file: *File,
     scope: *Scope,
     fields_len: usize,
-    field_type_refs: *std.ArrayListUnmanaged(DocData.WalkResult),
+    field_type_refs: *std.ArrayListUnmanaged(DocData.Expr),
     field_name_indexes: *std.ArrayListUnmanaged(usize),
     ei: usize,
 ) !void {
@@ -2410,8 +2452,8 @@ fn collectStructFieldInfo(
 
         // type
         {
-            const walk_result = try self.walkRef(file, scope, field_type);
-            try field_type_refs.append(self.arena, walk_result);
+            const walk_result = try self.walkRef(file, scope, field_type, false);
+            try field_type_refs.append(self.arena, walk_result.expr);
         }
 
         // ast node
@@ -2436,13 +2478,17 @@ fn walkRef(
     file: *File,
     parent_scope: *Scope,
     ref: Ref,
+    need_type: bool, // true when the caller needs also a typeRef for the return value
 ) !DocData.WalkResult {
     const enum_value = @enumToInt(ref);
     if (enum_value <= @enumToInt(Ref.anyerror_void_error_union_type)) {
         // We can just return a type that indexes into `types` with the
         // enum value because in the beginning we pre-filled `types` with
         // the types that are listed in `Ref`.
-        return DocData.WalkResult{ .type = enum_value };
+        return DocData.WalkResult{
+            .typeRef = .{ .type = @enumToInt(std.builtin.TypeId.Type) },
+            .expr = .{ .type = enum_value },
+        };
     } else if (enum_value < Ref.typed_value_map.len) {
         switch (ref) {
             else => {
@@ -2451,69 +2497,62 @@ fn walkRef(
                 });
             },
             .undef => {
-                var t = try self.arena.create(DocData.WalkResult);
-                t.* = .void;
-
-                return DocData.WalkResult{ .@"undefined" = t };
+                return DocData.WalkResult{ .expr = .@"undefined" };
             },
             .zero => {
-                var t = try self.arena.create(DocData.WalkResult);
-                t.* = .{ .type = @enumToInt(Ref.comptime_int_type) };
-                return DocData.WalkResult{ .int = .{
-                    .typeRef = t,
-                    .value = 0,
-                } };
+                return DocData.WalkResult{
+                    .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+                    .expr = .{ .int = .{ .value = 0 } },
+                };
             },
             .one => {
-                var t = try self.arena.create(DocData.WalkResult);
-                t.* = .{ .type = @enumToInt(Ref.comptime_int_type) };
-                return DocData.WalkResult{ .int = .{
-                    .typeRef = t,
-                    .value = 1,
-                } };
+                return DocData.WalkResult{
+                    .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+                    .expr = .{ .int = .{ .value = 1 } },
+                };
             },
 
             .void_value => {
-                return DocData.WalkResult{ .void = {} };
+                return DocData.WalkResult{
+                    .typeRef = .{ .type = @enumToInt(Ref.void_type) },
+                    .expr = .{ .void = {} },
+                };
             },
             .unreachable_value => {
-                return DocData.WalkResult{ .@"unreachable" = {} };
+                return DocData.WalkResult{
+                    .typeRef = .{ .type = @enumToInt(Ref.noreturn_type) },
+                    .expr = .{ .@"unreachable" = {} },
+                };
             },
             .null_value => {
-                var t = try self.arena.create(DocData.WalkResult);
-                t.* = .void;
-                return DocData.WalkResult{ .@"null" = t };
+                return DocData.WalkResult{ .expr = .@"null" };
             },
             .bool_true => {
-                return DocData.WalkResult{ .bool = true };
+                return DocData.WalkResult{
+                    .typeRef = .{ .type = @enumToInt(Ref.bool_type) },
+                    .expr = .{ .bool = true },
+                };
             },
             .bool_false => {
-                return DocData.WalkResult{ .bool = false };
+                return DocData.WalkResult{
+                    .typeRef = .{ .type = @enumToInt(Ref.bool_type) },
+                    .expr = .{ .bool = false },
+                };
             },
             .empty_struct => {
-                var t = try self.arena.create(DocData.WalkResult);
-                t.* = .void;
-
-                return DocData.WalkResult{ .@"struct" = .{
-                    .typeRef = t,
-                    .fieldVals = &.{},
-                } };
+                return DocData.WalkResult{ .expr = .{ .@"struct" = &.{} } };
             },
             .zero_usize => {
-                var t = try self.arena.create(DocData.WalkResult);
-                t.* = .{ .type = @enumToInt(Ref.usize_type) };
-                return DocData.WalkResult{ .int = .{
-                    .typeRef = t,
-                    .value = 0,
-                } };
+                return DocData.WalkResult{
+                    .typeRef = .{ .type = @enumToInt(Ref.usize_type) },
+                    .expr = .{ .int = .{ .value = 0 } },
+                };
             },
             .one_usize => {
-                var t = try self.arena.create(DocData.WalkResult);
-                t.* = .{ .type = @enumToInt(Ref.usize_type) };
-                return DocData.WalkResult{ .int = .{
-                    .typeRef = t,
-                    .value = 1,
-                } };
+                return DocData.WalkResult{
+                    .typeRef = .{ .type = @enumToInt(Ref.usize_type) },
+                    .expr = .{ .int = .{ .value = 1 } },
+                };
             },
             // TODO: dunno what to do with those
             // .calling_convention_c => {
@@ -2537,29 +2576,10 @@ fn walkRef(
         }
     } else {
         const zir_index = enum_value - Ref.typed_value_map.len;
-        return self.walkInstruction(file, parent_scope, zir_index);
+        return self.walkInstruction(file, parent_scope, zir_index, need_type);
     }
 }
 
-/// Given a WalkResult, tries to find its type.
-/// Used to analyze instructions like `array_init`, which require us to
-/// inspect its first element to find out the array type.
-fn typeOfWalkResult(self: *Autodoc, wr: DocData.WalkResult) !DocData.WalkResult {
-    return switch (wr) {
-        else => {
-            std.debug.print(
-                "TODO: handle `{s}` in typeOfWalkResult\n",
-                .{@tagName(wr)},
-            );
-            return self.cteTodo(@tagName(wr));
-        },
-        .type => .{ .type = @enumToInt(DocData.DocTypeKinds.Type) },
-        .int => |v| v.typeRef.*,
-        .float => |v| v.typeRef.*,
-        .array => |v| v.typeRef.*,
-    };
-}
-
 fn getBlockInlineBreak(zir: Zir, inst_index: usize) Zir.Inst.Ref {
     const tags = zir.instructions.items(.tag);
     const data = zir.instructions.items(.data);
@@ -2585,7 +2605,6 @@ fn cteTodo(self: *Autodoc, msg: []const u8) error{OutOfMemory}!DocData.WalkResul
     const cte_slot_index = self.comptime_exprs.items.len;
     try self.comptime_exprs.append(self.arena, .{
         .code = msg,
-        .typeRef = .{ .type = @enumToInt(DocData.DocTypeKinds.ComptimeExpr) },
     });
-    return DocData.WalkResult{ .comptimeExpr = cte_slot_index };
+    return DocData.WalkResult{ .expr = .{ .comptimeExpr = cte_slot_index } };
 }

From aa545dbd1e7a8b1179f8e4714324a242cde4d41f Mon Sep 17 00:00:00 2001
From: Loris Cro 
Date: Sun, 22 May 2022 16:21:49 +0200
Subject: [PATCH 054/137] autodoc: improve frontend rendering

---
 lib/docs/main.js | 709 ++++++++++++++++++++---------------------------
 src/Autodoc.zig  |  25 +-
 2 files changed, 327 insertions(+), 407 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index ded13b7799..3f700e7352 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -32,6 +32,13 @@
    } TypeKind
 */
 
+/**
+ * @typedef {{
+     typeRef: Expr?,
+     expr: Expr,
+   }} WalkResult
+*/
+
 /**
  * @typedef {{
      void: {},
@@ -40,20 +47,20 @@
      type: number,
      comptimeExpr: number,
      call: number,
-     int: { typeRef: WalkResult; value: number },
-     float: { typeRef: WalkResult; value: number },
+     int: number,
+     float: number,
      bool: boolean,
      undefined: WalkResult,
      null: WalkResult,
      typeOf: WalkResult,
-     compileError: string,
+     compileError: string
      string: string,
-     struct: Struct,
-     refPath: WalkResult[],
+     struct: Expr[],
+     refPath: Expr[],
      declRef: number,
      array: ZigArray,
      enumLiteral: string,
-   }} WalkResult
+   }} Expr
 */
 
 /**
@@ -128,7 +135,7 @@
 * @typedef {{
      kind: number,
      name: string,
-     child: WalkResult
+     child: Expr,
 }} OptionalType
 */
 
@@ -148,9 +155,9 @@
 
 /**
  * @typedef {{
-       func: WalkResult,
-       args: WalkResult[],
-       ret: WalkResult,
+       func: Expr,
+       args: Expr[],
+       ret: Expr,
    }} Call
 */
 
@@ -188,13 +195,6 @@
    }} Package
 */
 
-/**
- * @typedef {{
-     typeRef: WalkResult,
-     fieldVals: WalkResult[],
-   }} Struct
-*/
-
 /**
  * @typedef {{
       typeRef: WalkResult,
@@ -391,13 +391,13 @@ var zigAnalysis;
         return isType(x) && typeKindIsContainer(/** @type {Type} */(x).kind) ;
     }
 
-    /** @param {WalkResult} wr */
-    function typeShorthandName(wr) {
-        let resolvedWr = resolveValue(wr);
-        if (!("type" in resolvedWr)) {
+    /** @param {Expr} expr */
+    function typeShorthandName(expr) {
+        let resolvedExpr = resolveValue({expr: expr});
+        if (!("type" in resolvedExpr)) {
             return null;
         }
-        let type = /** @type {Type} */(zigAnalysis.types[resolvedWr.type]);
+        let type = /** @type {Type} */(zigAnalysis.types[resolvedExpr.type]);
 
         outer: for (let i = 0; i < 10000; i += 1) {
             switch (type.kind) {
@@ -472,16 +472,24 @@ var zigAnalysis;
         while(i < 1000) {
             i += 1;
 
-            if ("refPath" in value) {
-                value = value.refPath[value.refPath.length -1];
+            if ("refPath" in value.expr) {
+                value = {expr: value.expr.refPath[value.expr.refPath.length -1]};
                 continue;
             }
 
-            if ("declRef" in value) {
-                value = zigAnalysis.decls[value.declRef].value;
+            if ("declRef" in value.expr) {
+                value = zigAnalysis.decls[value.expr.declRef].value;
                 continue;
             }
 
+//            if ("as" in value.expr) {
+//                value = {
+//                  typeRef: zigAnalysis.exprs[value.expr.as.typeRefArg],
+//                  expr: zigAnalysis.exprs[value.expr.as.exprArg],
+//                };
+//                continue;
+//            }
+
             return value;
 
         }
@@ -493,89 +501,89 @@ var zigAnalysis;
         * @param {Decl} decl
         * @return {WalkResult}
     */
-    function typeOfDecl(decl){
-        return decl.value.typeRef;
-
-        let i = 0;
-        while(i < 1000) {
-            i += 1;
-            console.assert(isDecl(decl));
-            if ("type" in decl.value) {
-                return /** @type {WalkResult} */({ type: typeTypeId });
-            }
-
-//            if ("string" in decl.value) {
-//                return /** @type {WalkResult} */({ type: {
-//                  kind: typeKinds.Pointer,
-//                  size: pointerSizeEnum.One,
-//                  child: });
+//    function typeOfDecl(decl){
+//        return decl.value.typeRef;
+//
+//        let i = 0;
+//        while(i < 1000) {
+//            i += 1;
+//            console.assert(isDecl(decl));
+//            if ("type" in decl.value) {
+//                return /** @type {WalkResult} */({ type: typeTypeId });
 //            }
-
-            if ("refPath" in decl.value) {
-                decl =  /** @type {Decl} */({
-                  value: decl.value.refPath[decl.value.refPath.length -1]
-                });
-                continue;
-            }
-
-            if ("declRef" in decl.value) {
-                decl = zigAnalysis.decls[decl.value.declRef];
-                continue;
-            }
-
-            if ("int" in decl.value) {
-                return decl.value.int.typeRef;
-            }
-
-            if ("float" in decl.value) {
-                return decl.value.float.typeRef;
-            }
-
-            if ("array" in decl.value) {
-                return decl.value.array.typeRef;
-            }
-
-            if ("struct" in decl.value) {
-                return decl.value.struct.typeRef;
-            }
-
-            if ("comptimeExpr" in decl.value) {
-                const cte = zigAnalysis.comptimeExprs[decl.value.comptimeExpr];
-                return cte.typeRef;
-            }
-
-            if ("call" in decl.value) {
-                const fn_call = zigAnalysis.calls[decl.value.call];
-                let fn_decl = undefined;
-                if ("declRef" in fn_call.func) {
-                    fn_decl = zigAnalysis.decls[fn_call.func.declRef];
-                } else if ("refPath" in fn_call.func) {
-                    console.assert("declRef" in fn_call.func.refPath[fn_call.func.refPath.length -1]);
-                    fn_decl = zigAnalysis.decls[fn_call.func.refPath[fn_call.func.refPath.length -1].declRef];
-                } else throw {};
-
-                const fn_decl_value = resolveValue(fn_decl.value);
-                console.assert("type" in fn_decl_value); //TODO handle comptimeExpr
-                const fn_type = /** @type {Fn} */(zigAnalysis.types[fn_decl_value.type]);
-                console.assert(fn_type.kind === typeKinds.Fn);
-                return fn_type.ret;
-            }
-
-            if ("void" in decl.value) {
-                return /** @type {WalkResult} */({ type: typeTypeId });
-            }
-
-            if ("bool" in decl.value) {
-                return /** @type {WalkResult} */({ type: typeKinds.Bool });
-            }
-
-            console.log("TODO: handle in `typeOfDecl` more cases: ", decl);
-            console.assert(false);
-            throw {};
-        }
-        console.assert(false);
-        return /** @type {WalkResult} */({});
-    }
+//
+////            if ("string" in decl.value) {
+////                return /** @type {WalkResult} */({ type: {
+////                  kind: typeKinds.Pointer,
+////                  size: pointerSizeEnum.One,
+////                  child: });
+////            }
+//
+//            if ("refPath" in decl.value) {
+//                decl =  /** @type {Decl} */({
+//                  value: decl.value.refPath[decl.value.refPath.length -1]
+//                });
+//                continue;
+//            }
+//
+//            if ("declRef" in decl.value) {
+//                decl = zigAnalysis.decls[decl.value.declRef];
+//                continue;
+//            }
+//
+//            if ("int" in decl.value) {
+//                return decl.value.int.typeRef;
+//            }
+//
+//            if ("float" in decl.value) {
+//                return decl.value.float.typeRef;
+//            }
+//
+//            if ("array" in decl.value) {
+//                return decl.value.array.typeRef;
+//            }
+//
+//            if ("struct" in decl.value) {
+//                return decl.value.struct.typeRef;
+//            }
+//
+//            if ("comptimeExpr" in decl.value) {
+//                const cte = zigAnalysis.comptimeExprs[decl.value.comptimeExpr];
+//                return cte.typeRef;
+//            }
+//
+//            if ("call" in decl.value) {
+//                const fn_call = zigAnalysis.calls[decl.value.call];
+//                let fn_decl = undefined;
+//                if ("declRef" in fn_call.func) {
+//                    fn_decl = zigAnalysis.decls[fn_call.func.declRef];
+//                } else if ("refPath" in fn_call.func) {
+//                    console.assert("declRef" in fn_call.func.refPath[fn_call.func.refPath.length -1]);
+//                    fn_decl = zigAnalysis.decls[fn_call.func.refPath[fn_call.func.refPath.length -1].declRef];
+//                } else throw {};
+//
+//                const fn_decl_value = resolveValue(fn_decl.value);
+//                console.assert("type" in fn_decl_value); //TODO handle comptimeExpr
+//                const fn_type = /** @type {Fn} */(zigAnalysis.types[fn_decl_value.type]);
+//                console.assert(fn_type.kind === typeKinds.Fn);
+//                return fn_type.ret;
+//            }
+//
+//            if ("void" in decl.value) {
+//                return /** @type {WalkResult} */({ type: typeTypeId });
+//            }
+//
+//            if ("bool" in decl.value) {
+//                return /** @type {WalkResult} */({ type: typeKinds.Bool });
+//            }
+//
+//            console.log("TODO: handle in `typeOfDecl` more cases: ", decl);
+//            console.assert(false);
+//            throw {};
+//        }
+//        console.assert(false);
+//        return /** @type {WalkResult} */({});
+//    }
 
     function render() {
         domStatus.classList.add("hidden");
@@ -637,7 +645,7 @@ var zigAnalysis;
                 return render404();
             }
 
-            let childDeclValue = resolveValue(/** @type {Decl} */(childDecl).value);
+            let childDeclValue = resolveValue(/** @type {Decl} */(childDecl).value).expr;
             if ("type" in childDeclValue) {
 
                 const t = zigAnalysis.types[childDeclValue.type];
@@ -674,7 +682,7 @@ var zigAnalysis;
         }
 
         if (lastIsDecl && last.kind === 'const') {
-            let typeObj = zigAnalysis.types[resolveValue(/** @type {Decl} */(last).value).type];
+            let typeObj = zigAnalysis.types[resolveValue(/** @type {Decl} */(last).value).expr.type];
             if (typeObj && typeObj.kind === typeKinds.Fn) {
                 return renderFn(/** @type {Decl} */(last));
             }
@@ -721,11 +729,22 @@ var zigAnalysis;
 
     /** @param {Decl} fnDecl */
     function renderFn(fnDecl) {
-        let value = resolveValue(fnDecl.value);
-        console.assert("type" in value);
-        let typeObj = /** @type {Fn} */(zigAnalysis.types[value.type]);
+        if ("refPath" in fnDecl.value.expr) {
+            let last = fnDecl.value.expr.refPath.length - 1;
+            let lastExpr = fnDecl.value.expr.refPath[last];
+            console.assert("declRef" in lastExpr);
+            fnDecl = zigAnalysis.decls[lastExpr.declRef];
+        }
 
-        domFnProtoCode.innerHTML = typeValueName(value, true, true, fnDecl);
+        let value = resolveValue(fnDecl.value);
+        console.assert("type" in value.expr);
+        let typeObj = /** @type {Fn} */(zigAnalysis.types[value.expr.type]);
+
+        domFnProtoCode.innerHTML = exprName(value.expr, {
+          wantHtml: true,
+          wantLink: true,
+          fnDecl,
+        });
 
         let docsSource = null;
         let srcNode = zigAnalysis.astNodes[fnDecl.src];
@@ -733,23 +752,26 @@ var zigAnalysis;
             docsSource = srcNode.docs;
         }
 
-        let retIndex = resolveValue(typeObj.ret).type;
         renderFnParamDocs(fnDecl, typeObj);
 
-        let errSetTypeIndex = /** @type {number | null} */(null);
-        let retType = zigAnalysis.types[retIndex];
-        if (retType.kind === typeKinds.ErrorSet) {
-            errSetTypeIndex = retIndex;
-        } else if (retType.kind === typeKinds.ErrorUnion) {
-            errSetTypeIndex = /** @type {ErrUnionType} */(retType).err.type;
-        }
-        if (errSetTypeIndex != null) {
-            let errSetType = /** @type {ErrSetType} */(zigAnalysis.types[errSetTypeIndex]);
-            renderErrorSet(errSetType);
+        let retExpr = resolveValue({expr:typeObj.ret}).expr;
+        if ("type" in retExpr) {
+            let retIndex = retExpr.type;
+            let errSetTypeIndex = /** @type {number | null} */(null);
+            let retType = zigAnalysis.types[retIndex];
+            if (retType.kind === typeKinds.ErrorSet) {
+                errSetTypeIndex = retIndex;
+            } else if (retType.kind === typeKinds.ErrorUnion) {
+                errSetTypeIndex = /** @type {ErrUnionType} */(retType).err.type;
+            }
+            if (errSetTypeIndex != null) {
+                let errSetType = /** @type {ErrSetType} */(zigAnalysis.types[errSetTypeIndex]);
+                renderErrorSet(errSetType);
+            }
         }
 
         let protoSrcIndex = fnDecl.src;
-        if (typeIsGenericFn(value.type)) {
+        if (typeIsGenericFn(value.expr.type)) {
             throw "TODO";
             // let instantiations = nodesToFnsMap[protoSrcIndex];
             // let calls = nodesToCallsMap[protoSrcIndex];
@@ -827,7 +849,7 @@ var zigAnalysis;
             if (isVarArgs && i === typeObj.params.length - 1) {
                 html += '...';
             } else {
-                let name = typeValueName(value, false, false);
+                let name = exprName(value, {wantHtml: false, wantLink: false});
                 html += '' + name + '';
             }
 
@@ -1017,19 +1039,72 @@ var zigAnalysis;
             listDom.removeChild(listDom.lastChild);
         }
     }
-
      /**
-    * @typedef {{
-        wantHtml: boolean,
-    }} RenderWrOptions
-    * @param {WalkResult} wr,
-    * @param {RenderWrOptions} opts,
-    * @return {string}
+      * @param {WalkResult} wr,
+      * @return {Expr}
+    */
+    function walkResultTypeRef(wr) {
+      if (wr.typeRef) return wr.typeRef;
+      return walkResultTypeRef(resolveValue(wr));
+    }
+     /**
+      * @typedef {{
+          wantHtml: boolean,
+      }} RenderWrOptions
+      * @param {Expr} expr,
+      * @param {RenderWrOptions} opts,
+      * @return {string}
     */
-
     function exprName(expr, opts) {
-        const activeField = Object.keys(expr)[0];
-        switch (activeField) {
+        switch (Object.keys(expr)[0]) {
+          default: throw "oh no";
+          case "array": {
+            let payloadHtml = ".{";
+            for (let i = 0; i < expr.array.length; i++) {
+                if (i != 0) payloadHtml += ", ";
+                let elem = zigAnalysis.exprs[expr.array[i]];
+                payloadHtml += exprName(elem);
+            }
+            return payloadHtml + "}";
+          }
+          case "comptimeExpr": {
+              return "[ComptimeExpr]";
+          }
+          case "call": {
+              let call = zigAnalysis.calls[expr.call];
+              let payloadHtml = "";
+
+
+              switch(Object.keys(call.func)[0]){
+                default: throw "TODO";
+                case "declRef":
+                case "refPath": {
+                    payloadHtml += exprName(call.func);
+                    break;
+                }
+              }
+              payloadHtml += "(";
+
+              for (let i = 0; i < call.args.length; i++) {
+                  if (i != 0) payloadHtml += ", ";
+                  payloadHtml += exprName(call.args[i]);
+              }
+
+              payloadHtml += ")";
+              return payloadHtml;
+          }
+          case "as": {
+              const typeRefArg = zigAnalysis.exprs[expr.as.typeRefArg];
+              const exprArg = zigAnalysis.exprs[expr.as.exprArg];
+              return "@as(" + exprName(typeRefArg, opts) +
+                ", " + exprName(exprArg, opts) + ")";
+          }
+          case "declRef": {
+            return zigAnalysis.decls[expr.declRef].name;
+          }
+          case "refPath": {
+            return expr.refPath.map(x => exprName(x, opts)).join(".");
+          }
           case "int": {
               return "" + expr.int;
           }
@@ -1047,8 +1122,12 @@ var zigAnalysis;
 
           case "type": {
               let name = "";
-              const typeObj = zigAnalysis.types[expr.type];
+
+              let typeObj = expr.type;
+              if (typeof typeObj === 'number') typeObj = zigAnalysis.types[typeObj];
+
               switch (typeObj.kind) {
+                  default: throw "TODO";
                   case typeKinds.Array:
                   {
                       let arrayObj = /** @type {ArrayType} */(typeObj);
@@ -1064,8 +1143,7 @@ var zigAnalysis;
                       return name;
                   }
                   case typeKinds.Optional:
-
-                      return "?" + typeValueName(/**@type {OptionalType} */(typeObj).child, wantHtml, wantSubLink, fnDecl, linkFnNameDecl);
+                      return "?" + exprName(/**@type {OptionalType} */(typeObj).child, opts);
                   case typeKinds.Pointer:
                   {
                       let ptrObj = /** @type {PointerType} */(typeObj);
@@ -1135,7 +1213,7 @@ var zigAnalysis;
                   {
                       let floatObj = /** @type {NumberType} */ (typeObj);
 
-                      if (wantHtml) {
+                      if (opts.wantHtml) {
                           return '' + floatObj.name + '';
                       } else {
                           return floatObj.name;
@@ -1152,43 +1230,43 @@ var zigAnalysis;
                       }
                   }
                   case typeKinds.ComptimeInt:
-                      if (wantHtml) {
+                      if (opts.wantHtml) {
                           return 'comptime_int';
                       } else {
                           return "comptime_int";
                       }
                   case typeKinds.ComptimeFloat:
-                      if (wantHtml) {
+                      if (opts.wantHtml) {
                           return 'comptime_float';
                       } else {
                           return "comptime_float";
                       }
                   case typeKinds.Type:
-                      if (wantHtml) {
+                      if (opts.wantHtml) {
                           return 'type';
                       } else {
                           return "type";
                       }
                   case typeKinds.Bool:
-                      if (wantHtml) {
+                      if (opts.wantHtml) {
                           return 'bool';
                       } else {
                           return "bool";
                       }
                   case typeKinds.Void:
-                      if (wantHtml) {
+                      if (opts.wantHtml) {
                           return 'void';
                       } else {
                           return "void";
                       }
                   case typeKinds.EnumLiteral:
-                      if (wantHtml) {
+                      if (opts.wantHtml) {
                           return '(enum literal)';
                       } else {
                           return "(enum literal)";
                       }
                   case typeKinds.NoReturn:
-                      if (wantHtml) {
+                      if (opts.wantHtml) {
                           return 'noreturn';
                       } else {
                           return "noreturn";
@@ -1230,20 +1308,20 @@ var zigAnalysis;
                   {
                       let fnObj = /** @type {Fn} */(typeObj);
                       let payloadHtml = "";
-                      if (wantHtml) {
+                      if (opts.wantHtml) {
                           payloadHtml += 'fn';
-                          if (fnDecl != null) {
+                          if (opts.fnDecl) {
                               payloadHtml += ' ';
-                              if (linkFnNameDecl != null) {
-                                  payloadHtml += '' +
-                                      escapeHtml(fnDecl.name) + '';
+                              if (opts.linkFnNameDecl) {
+                                  payloadHtml += '' +
+                                      escapeHtml(opts.fnDecl.name) + '';
                               } else {
-                                  payloadHtml += escapeHtml(fnDecl.name);
+                                  payloadHtml += escapeHtml(opts.fnDecl.name);
                               }
                               payloadHtml += '';
                           }
                       } else {
-                          payloadHtml += 'fn'
+                          payloadHtml += 'fn ';
                       }
                       payloadHtml += '(';
                           if (fnObj.params) {
@@ -1259,7 +1337,7 @@ var zigAnalysis;
                                   }
 
                                   let value = fnObj.params[i];
-                                  let paramValue = resolveValue(value);
+                                  let paramValue = resolveValue({expr: value});
 
                                   if (fields != null) {
                                       let paramNode = zigAnalysis.astNodes[fields[i]];
@@ -1270,7 +1348,7 @@ var zigAnalysis;
                                       }
 
                                       if (paramNode.noalias) {
-                                          if (wantHtml) {
+                                          if (opts.wantHtml) {
                                               payloadHtml += 'noalias ';
                                           } else {
                                               payloadHtml += 'noalias ';
@@ -1278,7 +1356,7 @@ var zigAnalysis;
                                       }
 
                                       if (paramNode.comptime) {
-                                          if (wantHtml) {
+                                          if (opts.wantHtml) {
                                               payloadHtml += 'comptime ';
                                           } else {
                                               payloadHtml += 'comptime ';
@@ -1297,35 +1375,48 @@ var zigAnalysis;
                                   if (isVarArgs && i === fnObj.params.length - 1) {
                                       payloadHtml += '...';
                                   } else if ("refPath" in value) {
-                                      payloadHtml += '';
-                                      payloadHtml += '[Ref Path]';
-                                      payloadHtml += '';
+                                      if (opts.wantHtml) {
+                                          payloadHtml += '';
+                                          payloadHtml +=
+                                            ''
+                                              + exprName(value, opts) + '';
+                                          payloadHtml += '';
+                                      } else {
+                                          payloadHtml += exprName(value, opts);
+                                      }
 
                                   } else if ("type" in value) {
-                                      let name = typeValueName(value, false, false, fnDecl, linkFnNameDecl);
+                                      let name = exprName(value, {
+                                        wantHtml: false,
+                                        wantLink: false,
+                                        fnDecl: opts.fnDecl,
+                                        linkFnNameDecl: opts.linkFnNameDecl,
+                                      });
                                       payloadHtml += '' + escapeHtml(name) + '';
                                   } else if ("comptimeExpr" in value) {
-                                      payloadHtml += '[ComptimeExpr]';
-                                  } else if (wantHtml) {
-                                      payloadHtml += 'var';
+                                      if (opts.wantHtml) {
+                                        payloadHtml += '[ComptimeExpr]';
+                                      } else {
+                                        payloadHtml += "[ComptimeExpr]";
+                                      }
+                                  } else if (opts.wantHtml) {
+                                      payloadHtml += 'anytype';
                                   } else {
-                                      payloadHtml += 'var';
+                                      payloadHtml += 'anytype';
                                   }
                               }
                           }
 
                       payloadHtml += ') ';
                       if (fnObj.ret != null) {
-                          payloadHtml += typeValueName(fnObj.ret, wantHtml, wantSubLink, fnDecl);
-                      } else if (wantHtml) {
+                          payloadHtml += exprName(fnObj.ret, opts);
+                      } else if (opts.wantHtml) {
                           payloadHtml += 'anytype';
                       } else {
                           payloadHtml += 'anytype';
                       }
                       return payloadHtml;
                   }
-                  default:
-                      throw "TODO";
                       // if (wantHtml) {
                       //     return escapeHtml(typeObj.name);
                       // } else {
@@ -1334,104 +1425,16 @@ var zigAnalysis;
               }
         }
 
-          default: throw "oh no";
         }
     }
 
 
     /**
-    * @param {WalkResult} typeValue,
-    * @param {boolean} wantHtml,
-    * @param {boolean} wantLink,
-    * @param {Decl | null} [fnDecl],
-    * @param {string} [linkFnNameDecl],
-    * @return {string}
-    */
-    function typeValueName(typeValue, wantHtml, wantLink, fnDecl, linkFnNameDecl) {
-
-        if ("int" in typeValue) {
-            return "" + typeValue.int.value;
-        }
-        if ("call" in typeValue) {
-            let result = "";
-            let call = zigAnalysis.calls[typeValue.call];
-            let functionName = typeValueName(call.func, wantHtml, wantLink, fnDecl, linkFnNameDecl);
-            result += functionName + "(";
-            for (let j = 0; j < call.args.length; j += 1) {
-              result += typeValueName(call.args[j], wantHtml, wantLink, fnDecl, linkFnNameDecl);
-              if (j != call.args.length -1) result += ",";
-            }
-
-            return result + ")";
-        }
-        if ("comptimeExpr" in typeValue) {
-            return "[ComptimeExpr]";
-        }
-        if ("refPath" in typeValue) {
-              let result = "";
-              for (let j = 0; j < typeValue.refPath.length; j++) {
-
-                  let name = "[RefPath]";
-                  if (wantHtml) {
-                      //result += '';
-                      result += '';
-                      result += '' +
-                           name + '';
-                      result += '';
-                  } else {
-                      result += name;
-                  }
-
-                  if (j != 0) result += ".";
-            }
-
-            return result;
-        }
-
-        if ("declRef" in typeValue) {
-            return zigAnalysis.decls[typeValue.declRef].name;
-        }
-
-        if ("string" in typeValue) {
-            return typeValue.string + " (string)";
-        }
-
-        if ("anytype" in typeValue) {
-            return "anytype";
-        }
-
-        if ("this" in typeValue) {
-            return "this";
-        }
-
-        console.assert("type" in typeValue)
-        let typeIndex = typeValue.type;
-        let typeObj = zigAnalysis.types[typeIndex];
-        if (wantLink) {
-            let declIndex = getCanonTypeDecl(typeIndex);
-            let declPath = getCanonDeclPath(declIndex);
-            if (declPath == null) {
-                return typeName(typeObj, wantHtml, wantLink, fnDecl, linkFnNameDecl);
-            }
-            let name = (wantLink && declCanRepresentTypeKind(typeObj.kind)) ?
-                declPath.declNames[declPath.declNames.length - 1] :
-                typeName(typeObj, wantHtml, false, fnDecl, linkFnNameDecl);
-            if (wantLink && wantHtml) {
-                return '' + name + '';
-            } else {
-                return name;
-            }
-        } else {
-            return typeName(typeObj, wantHtml, false, fnDecl, linkFnNameDecl);
-        }
-    }
-
-    /**
-    * @param {WalkResult} typeRef
+    * @param {Expr} typeRef
     * @param {string} paramName
     */
     function shouldSkipParamName(typeRef, paramName) {
-        let resolvedTypeRef = resolveValue(typeRef);
+        let resolvedTypeRef = resolveValue({expr: typeRef});
         if ("type" in resolvedTypeRef) {
             let typeObj = zigAnalysis.types[resolvedTypeRef.type];
             if (typeObj.kind === typeKinds.Pointer){
@@ -1450,69 +1453,13 @@ var zigAnalysis;
         return (typeObj.size == null) ? pointerSizeEnum.One : typeObj.size;
     }
 
-    // function getCallHtml(fnDecl, callIndex) {
-    //     let callObj = zigAnalysis.calls[callIndex];
-
-    //     // TODO make these links work
-    //     //let html = '' + escapeHtml(fnDecl.name) + '(';
-    //         let html = escapeHtml(fnDecl.name) + '(';
-    //             for (let arg_i = 0; arg_i < callObj.args.length; arg_i += 1) {
-    //                 if (arg_i !== 0) html += ', ';
-    //                 let argObj = callObj.args[arg_i];
-    //                 html += getValueText(argObj, argObj.value, true, true);
-    //             }
-    //             html += ')';
-    //         return html;
-    //     }
-
-   //  /**
-   //  * @param {WalkResult} typeRef
-   //  * @param {any} value
-   //  * @param {boolean} wantHtml
-   //  * @param {boolean} wantLink
-   //  */
-   //  function getValueText(typeRef, value, wantHtml, wantLink) {
-   //      let resolvedTypeRef = resolveValue(typeRef);
-   //      if ("comptimeExpr" in resolvedTypeRef) {
-   //          return "[ComptimeExpr]";
-   //      }
-   //      console.assert("type" in resolvedTypeRef);
-   //      let typeObj = zigAnalysis.types[typeRef.type];
-   //      switch (typeObj.kind) {
-   //          case typeKinds.Type:
-   //              return typeValueName(value, wantHtml, wantLink);
-   //          case typeKinds.Fn:
-   //              let fnObj = zigAnalysis.fns[value];
-   //              return typeName(fnObj, wantHtml, wantLink);
-   //          case typeKinds.Int:
-   //              if (wantHtml) {
-   //                  return '' + value + '';
-   //              } else {
-   //                  return value + "";
-   //              }
-   //          default:
-   //              console.trace("TODO implement getValueText for this type:", zigAnalysis.typeKinds[typeObj.kind]);
-   //      }
-   //  }
-
-    /**
-    * @param {Type} typeObj,
-    * @param {boolean} wantHtml,
-    * @param {boolean} wantSubLink,
-    * @param {Decl | null} [fnDecl],
-    * @param {string} [linkFnNameDecl],
-    * @return {string}
-    */
-    function typeName(typeObj, wantHtml, wantSubLink, fnDecl, linkFnNameDecl) {
-    }
-
     /** @param {Type} typeObj */
     function renderType(typeObj) {
         let name;
         if (rootIsStd && typeObj === zigAnalysis.types[zigAnalysis.packages[zigAnalysis.rootPkg].main]) {
             name = "std";
         } else {
-            name = typeName(typeObj, false, false);
+            name = exprName({type:typeObj}, false, false);
         }
         if (name != null && name != "") {
             domHdrName.innerText = name + " (" + zigAnalysis.typeKinds[typeObj.kind] + ")";
@@ -1626,54 +1573,14 @@ var zigAnalysis;
 //     }
 
 
-    // function mergeDecls(declObj, nextDeclIndex, firstTypeObj, typeObj) {
-    //     let nextDeclObj = zigAnalysis.decls[nextDeclIndex];
-    //     if (declObj.type != null && nextDeclObj.type != null && declObj.type !== nextDeclObj.type) {
-    //         if (typeof(declObj.type) !== 'object') {
-    //             let prevType = declObj.type;
-    //             declObj.type = {};
-    //             declObj.type[prevType] = firstTypeObj;
-    //             declObj.value = null;
-    //         }
-    //         declObj.type[nextDeclObj.type] = typeObj;
-    //     } else if (declObj.type == null && nextDeclObj != null) {
-    //         declObj.type = nextDeclObj.type;
-    //     }
-    //     if (declObj.value != null && nextDeclObj.value != null && declObj.value !== nextDeclObj.value) {
-    //         if (typeof(declObj.value) !== 'object') {
-    //             let prevValue = declObj.value;
-    //             declObj.value = {};
-    //             declObj.value[prevValue] = firstTypeObj;
-    //         }
-    //         declObj.value[nextDeclObj.value] = typeObj;
-    //     } else if (declObj.value == null && nextDeclObj.value != null) {
-    //         declObj.value = nextDeclObj.value;
-    //     }
-    // }
 
     /** @param {Decl} decl */
     function renderValue(decl) {
-
-        let declTypeRef = decl.value.typeRef;
-        let declValueText = exprName(decl.value.expr);
-//        switch(Object.keys(decl.value)[0]) {
-//            case "int":
-//                declValueText += /** @type {{int: {value: number}}} */(decl.value).int.value;
-//                break;
-//            case "float":
-//                declValueText += /** @type {{float: {value: number}}} */(decl.value).float.value;
-//                break;
-//            case "comptimeExpr":
-//                declValueText += "[ComptimeExpr]";
-//                break;
-//            default:
-//                console.log("TODO: renderValue for ", Object.keys(decl.value)[0]);
-//                declValueText += "#TODO#";
-//        }
+        let resolvedValue = resolveValue(decl.value)
 
         domFnProtoCode.innerHTML = 'const ' +
-            escapeHtml(decl.name) + ': ' + exprName(declTypeRef, {wantHtml: true}) +
-            " = " + declValueText;
+            escapeHtml(decl.name) + ': ' + exprName(resolvedValue.typeRef, {wantHtml: true, wantLink:true}) +
+            " = " + exprName(decl.value.expr, {wantHtml: true, wantLink:true}) + ";";
 
         let docs = zigAnalysis.astNodes[decl.src].docs;
         if (docs != null) {
@@ -1729,43 +1636,36 @@ var zigAnalysis;
             }
 
             if (decl.kind === 'const') {
-                if ("call" in declValue) {
-                    let c  = zigAnalysis.calls[declValue.call];
-                    console.assert("comptimeExpr" in c.ret);
-                    let fDecl = resolveValue(c.func);
-                    if ("type" in fDecl) {
-                        console.assert("type" in fDecl);
-                        let fType = /** @type {Fn} */(zigAnalysis.types[fDecl.type]);
-                        console.assert("type" in fType.ret);
-                        if (fType.ret.type === typeTypeId) {
-                            typesList.push(decl);
-                        } else {
-                            valsList.push(decl);
-                        }
-                    } else {
-                        valsList.push(decl);
-                    }
-                } else if (!("type" in declValue)){
-                    valsList.push(decl);
-                } else {
-                    let value = zigAnalysis.types[declValue.type];
-                    let kind = value.kind;
-                    if (kind === typeKinds.Fn) {
-                        // TODO: handle CTE return types when we know their type.
-                        const resVal = resolveValue(/** @type {Fn} */(value).ret);
-                        if ("type" in resVal && resVal.type == typeTypeId) {
-                            typesList.push(decl);
+                if ("type" in declValue.expr) {
+                    // We have the actual type expression at hand.
+                    const typeExpr = zigAnalysis.types[declValue.expr.type];
+                    if (typeExpr.kind == typeKinds.Fn) {
+                        const funcRetExpr = resolveValue({
+                            expr: /** @type {Fn} */(typeExpr).ret
+                        });
+                        if ("type" in funcRetExpr && funcRetExpr.type != typeTypeId) {
+                            if (typeIsErrSet(declValue.expr.type)) {
+                                errSetsList.push(decl);
+                            } else if (typeIsStructWithNoFields(declValue.expr.type)) {
+                                namespacesList.push(decl);
+                            } else {
+                                typesList.push(decl);
+                            }
                         } else {
                             fnsList.push(decl);
                         }
-
-                    } else  if (typeIsErrSet(declValue.type)) {
-                        errSetsList.push(decl);
-                    } else if (typeIsStructWithNoFields(declValue.type)) {
-                        namespacesList.push(decl);
-                    } else {
+                     } else {
                         typesList.push(decl);
-                    }
+                     }
+                 } else if ("typeRef" in declValue) {
+                      if ("type" in declValue.typeRef && declValue.typeRef == typeTypeId) {
+                          // We don't know what the type expression is, but we know it's a type.
+                          typesList.push(decl);
+                      } else {
+                          valsList.push(decl);
+                      }
+                } else {
+                    valsList.push(decl);
                 }
             }
         }
@@ -1859,9 +1759,14 @@ var zigAnalysis;
                 let tdDesc = trDom.children[1];
 
                 let declType = resolveValue(decl.value);
-                console.assert("type" in declType);
+                console.assert("type" in declType.expr);
 
-                tdFnCode.innerHTML = typeValueName(declType, true, true, decl, navLinkDecl(decl.name));
+                tdFnCode.innerHTML = exprName(declType.expr,{
+                  wantHtml: true,
+                  wantLink: true,
+                  fnDecl: decl,
+                  linkFnNameDecl: navLinkDecl(decl.name),
+                });
 
                 let docs = zigAnalysis.astNodes[decl.src].docs;
                 if (docs != null) {
@@ -1874,7 +1779,7 @@ var zigAnalysis;
         }
 
         let containerNode = zigAnalysis.astNodes[container.src];
-        if (containerNode.fields) {
+        if (containerNode.fields && containerNode.fields.length > 0) {
             resizeDomList(domListFields, containerNode.fields.length, '
    ');
 
             for (let i = 0; i < containerNode.fields.length; i += 1) {
@@ -1887,11 +1792,11 @@ var zigAnalysis;
                 if (container.kind === typeKinds.Enum) {
                     html += ' = ' + fieldName + '';
                 } else {
-                    let fieldTypeWr = container.fields[i];
+                    let fieldTypeExpr = container.fields[i];
                     html += ": ";
-                    let name = typeValueName(fieldTypeWr, false, false);
+                    let name = exprName(fieldTypeExpr, false, false);
                     html += ''+ name +'';
-                    let tsn = typeShorthandName(fieldTypeWr);
+                    let tsn = typeShorthandName(fieldTypeExpr);
                     if (tsn) {
                         html += ' ('+ tsn +')';
 
@@ -1951,7 +1856,8 @@ var zigAnalysis;
                 tdNameA.setAttribute('href', navLinkDecl(decl.name));
                 tdNameA.textContent = decl.name;
 
-                tdType.innerHTML = typeValueName(typeOfDecl(decl), true, true);
+                tdType.innerHTML = exprName(walkResultTypeRef(decl.value),
+                  {wantHtml:true, wantLink:true});
 
                 let docs = zigAnalysis.astNodes[decl.src].docs;
                 if (docs != null) {
@@ -1978,7 +1884,8 @@ var zigAnalysis;
                 tdNameA.setAttribute('href', navLinkDecl(decl.name));
                 tdNameA.textContent = decl.name;
 
-                tdType.innerHTML = typeValueName(typeOfDecl(decl), true, true);
+                tdType.innerHTML = exprName(walkResultTypeRef(decl.value),
+                  {wantHtml:true, wantLink:true});
 
                 let docs = zigAnalysis.astNodes[decl.src].docs;
                 if (docs != null) {
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index de8cc3660d..ebfda4eec3 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -542,13 +542,14 @@ const DocData = struct {
         call: usize, // index in `calls`
         enumLiteral: []const u8, // direct value
         typeOf: usize, // index in `exprs`
-        as: struct {
-            typeRefArg: ?usize, // index in `exprs`
-            exprArg: usize, // index in `exprs`
-        },
+        as: As,
         sizeOf: usize, // index in `exprs`
         compileError: []const u8,
         string: []const u8, // direct value
+        const As = struct {
+            typeRefArg: ?usize, // index in `exprs`
+            exprArg: usize, // index in `exprs`
+        };
         const FieldRef = struct {
             type: usize, // index in `types`
             index: usize, // index in type.fields
@@ -592,12 +593,16 @@ const DocData = struct {
                     , .{v});
                 },
                 .sizeOf => |v| try std.json.stringify(v, options, w),
-                .as => |v| try std.json.stringify(v, options, w),
                 .fieldRef => |v| try std.json.stringify(
                     struct { fieldRef: FieldRef }{ .fieldRef = v },
                     options,
                     w,
                 ),
+                .as => |v| try std.json.stringify(
+                    struct { as: As }{ .as = v },
+                    options,
+                    w,
+                ),
                 .@"struct" => |v| try std.json.stringify(
                     struct { @"struct": []FieldVal }{ .@"struct" = v },
                     options,
@@ -774,7 +779,12 @@ fn walkInstruction(
             );
 
             return DocData.WalkResult{
-                .expr = .{ .compileError = operand.expr.string },
+                .expr = .{
+                    .compileError = switch (operand.expr) {
+                        .string => |s| s,
+                        else => "TODO: non-string @compileError arguments",
+                    },
+                },
             };
         },
         .enum_literal => {
@@ -1010,6 +1020,9 @@ fn walkInstruction(
         .decl_val, .decl_ref => {
             const str_tok = data[inst_index].str_tok;
             const decls_slot_index = parent_scope.resolveDeclName(str_tok.start);
+            // While it would make sense to grab the original decl's typeRef info,
+            // that decl might not have been analyzed yet! The frontend will have
+            // to navigate through all declRefs to find the underlying type.
             return DocData.WalkResult{ .expr = .{ .declRef = decls_slot_index } };
         },
         .field_val, .field_call_bind, .field_ptr, .field_type => {

From 5a4005323f0e234532fc81ca7f1e917754e02f11 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sun, 22 May 2022 21:41:18 -0300
Subject: [PATCH 055/137] add: sentiel

---
 src/Autodoc.zig | 174 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 174 insertions(+)

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index ebfda4eec3..efd9d1f4db 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -383,10 +383,12 @@ const DocData = struct {
         Pointer: struct {
             size: std.builtin.TypeInfo.Pointer.Size,
             child: Expr,
+            sentinel: ?usize = null,
         },
         Array: struct {
             len: Expr,
             child: Expr,
+            sentinel: ?usize = null,
         },
         Struct: struct {
             name: []const u8,
@@ -478,6 +480,11 @@ const DocData = struct {
                         \\
                     , .{@enumToInt(v.size)});
                     if (options.whitespace) |ws| try ws.outputIndent(w);
+                    try w.print(
+                        \\"sentinel": {},
+                        \\
+                    , .{v.sentinel});
+                    if (options.whitespace) |ws| try ws.outputIndent(w);
                     try w.print(
                         \\"child":
                     , .{});
@@ -754,11 +761,13 @@ fn walkInstruction(
                         .child = .{ .type = @enumToInt(Ref.u8_type) },
                     },
                 });
+                // const sentinel: ?usize = if (ptr.flags.has_sentinel) 0 else null;
                 const ptrTypeId = self.types.items.len;
                 try self.types.append(self.arena, .{
                     .Pointer = .{
                         .size = .One,
                         .child = .{ .type = arrTypeId },
+                        .sentinel = 0,
                         // TODO: add sentinel!
                     },
                 });
@@ -806,6 +815,24 @@ fn walkInstruction(
             // TODO: return the actual error union instread of cheating
             return self.walkRef(file, parent_scope, extra.data.rhs, need_type);
         },
+        .elem_type => {
+            const un_node = data[inst_index].un_node;
+            std.debug.print("un_node: {}\n", .{un_node});
+
+            var operand: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                un_node.operand,
+                false,
+            );
+
+            std.debug.print("operand: {}\n", .{operand});
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = operand.typeRef.?.type },
+                .expr = .{ .type = operand.expr.type },
+            };
+        },
         .ptr_type_simple => {
             const ptr = data[inst_index].ptr_type_simple;
             const type_slot_index = self.types.items.len;
@@ -826,6 +853,14 @@ fn walkInstruction(
             const ptr = data[inst_index].ptr_type;
             const extra = file.zir.extraData(Zir.Inst.PtrType, ptr.payload_index);
 
+            std.debug.print("ptr = {}\n", .{ptr});
+            std.debug.print("extra = {any}\n", .{extra});
+
+            const sentinel: ?usize = if (ptr.flags.has_sentinel) 0 else null;
+
+            std.debug.print("sentinel = {} {d}\n", .{ ptr.flags.has_sentinel, sentinel });
+            std.debug.print("type = {d}\n", .{@enumToInt(Ref.type_type)});
+
             const type_slot_index = self.types.items.len;
             const elem_type_ref = try self.walkRef(
                 file,
@@ -837,9 +872,12 @@ fn walkInstruction(
                 .Pointer = .{
                     .size = ptr.size,
                     .child = elem_type_ref.expr,
+                    .sentinel = sentinel,
                 },
             });
+            std.debug.print("type = {d}\n", .{type_slot_index});
             return DocData.WalkResult{
+                // .typeRef = .{ .type = type_slot_index },
                 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
                 .expr = .{ .type = type_slot_index },
             };
@@ -849,6 +887,11 @@ fn walkInstruction(
             const len = try self.walkRef(file, parent_scope, bin.lhs, false);
             const child = try self.walkRef(file, parent_scope, bin.rhs, false);
 
+            std.debug.print("AEHO\n", .{});
+            // std.debug.print("bin = {}\n", .{bin});
+            // std.debug.print("len = {}\n", .{len});
+            // std.debug.print("child = {}\n", .{child});
+
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
                 .Array = .{
@@ -861,6 +904,26 @@ fn walkInstruction(
                 .expr = .{ .type = type_slot_index },
             };
         },
+        .array_type_sentinel => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.ArrayTypeSentinel, pl_node.payload_index);
+            const len = try self.walkRef(file, parent_scope, extra.data.len, false);
+            const sentinel = try self.walkRef(file, parent_scope, extra.data.sentinel, false);
+            const elem_type = try self.walkRef(file, parent_scope, extra.data.elem_type, false);
+
+            const type_slot_index = self.types.items.len;
+            try self.types.append(self.arena, .{
+                .Array = .{
+                    .len = len.expr,
+                    .child = elem_type.expr,
+                    .sentinel = sentinel.expr.int.value,
+                },
+            });
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .type = type_slot_index },
+            };
+        },
         .array_init => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.MultiOp, pl_node.payload_index);
@@ -875,6 +938,7 @@ fn walkInstruction(
                 // we only ask to figure out type info for the first element
                 // as it will be used later on to find out the array type!
                 const wr = try self.walkRef(file, parent_scope, op, idx == 0);
+                std.debug.print("wr: {any}\n", .{wr});
 
                 if (idx == 0) {
                     array_type = wr.typeRef;
@@ -886,6 +950,102 @@ fn walkInstruction(
                 array_data[idx] = wr.expr.as.exprArg;
             }
 
+            const type_slot_index = self.types.items.len;
+            try self.types.append(self.arena, .{
+                .Array = .{ .len = .{
+                    .int = .{
+                        .value = operands.len,
+                        .negated = false,
+                    },
+                }, .child = array_type.? },
+            });
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = type_slot_index },
+                .expr = .{ .array = array_data },
+            };
+        },
+        .array_init_sent => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.MultiOp, pl_node.payload_index);
+            const operands = file.zir.refSlice(extra.end, extra.data.operands_len - 1);
+            const array_data = try self.arena.alloc(usize, operands.len);
+
+            // TODO: make sure that you want the array to be fully normalized for real
+            // then update this code to conform to your choice.
+
+            var array_type: ?DocData.Expr = null;
+            for (operands) |op, idx| {
+                // we only ask to figure out type info for the first element
+                // as it will be used later on to find out the array type!
+                const wr = try self.walkRef(file, parent_scope, op, idx == 0);
+                std.debug.print("wr: {any}\n", .{wr});
+                if (idx == 0) {
+                    array_type = wr.typeRef;
+                }
+
+                // We know that Zir wraps every operand in an @as expression
+                // so we want to peel it away and only save the target type
+                // once, since we need it later to define the array type.
+                array_data[idx] = wr.expr.as.exprArg;
+            }
+
+            // std.debug.print("array: {any}\n", .{array_data});
+
+            const type_slot_index = self.types.items.len;
+            try self.types.append(self.arena, .{
+                .Array = .{ .len = .{
+                    .int = .{
+                        .value = operands.len,
+                        .negated = false,
+                    },
+                }, .child = array_type.?, .sentinel = 0 },
+            });
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = type_slot_index },
+                .expr = .{ .array = array_data },
+            };
+        },
+        .array_init_anon => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.MultiOp, pl_node.payload_index);
+            const operands = file.zir.refSlice(extra.end, extra.data.operands_len);
+            const array_data = try self.arena.alloc(usize, operands.len);
+
+            // TODO: make sure that you want the array to be fully normalized for real
+            // then update this code to conform to your choice.
+
+            // std.debug.print("extra: {}\n", .{extra});
+            // std.debug.print("operands: {any}\n", .{operands});
+
+            var array_type: ?DocData.Expr = null;
+            for (operands) |op, idx| {
+                // we only ask to figure out type info for the first element
+                // as it will be used later on to find out the array type!
+                const wr = try self.walkRef(file, parent_scope, op, idx == 0);
+                // std.debug.print("wr: {any}\n", .{wr});
+
+                if (idx == 0) {
+                    array_type = wr.typeRef;
+                }
+                // std.debug.print("type: {}\n", .{@intToEnum(Ref, wr.typeRef.?.type)});
+
+                // create an untion to hold more than one type
+                switch (@intToEnum(Ref, wr.typeRef.?.type)) {
+                    .comptime_int_type => {
+                        array_data[idx] = wr.expr.int.value;
+                    },
+                    .comptime_float_type => {
+                        unreachable;
+                        // array_data[idx] = wr.expr.float;
+                    },
+                    else => continue,
+                }
+            }
+
+            // std.debug.print("array: {any}\n", .{array_data});
+
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
                 .Array = .{
@@ -904,6 +1064,20 @@ fn walkInstruction(
                 .expr = .{ .array = array_data },
             };
         },
+        // .validate_array_init_ty => {
+        //     const un_node = data[inst_index].un_node;
+        //     var operand: DocData.WalkResult = try self.walkRef(
+        //         file,
+        //         parent_scope,
+        //         un_node.operand,
+        //         need_type,
+        //     );
+        //
+        //     std.debug.print("validate _ array => {}\n", .{un_node});
+        //     std.debug.print("operand = {}\n", .{operand});
+        //
+        //     return operand;
+        // },
         .float => {
             const float = data[inst_index].float;
             return DocData.WalkResult{

From 646079c968dcc847806fceacefaf894f97dacfe4 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Mon, 23 May 2022 00:13:32 -0300
Subject: [PATCH 056/137] add: rendering sentinel in js and some fixes in
 autodoc

---
 lib/docs/main.js | 25 ++++++++++++++-----------
 src/Autodoc.zig  | 46 ++++------------------------------------------
 2 files changed, 18 insertions(+), 53 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 3f700e7352..4e78b760b3 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1130,17 +1130,20 @@ var zigAnalysis;
                   default: throw "TODO";
                   case typeKinds.Array:
                   {
-                      let arrayObj = /** @type {ArrayType} */(typeObj);
-                      let name = "[";
-                      let lenName = exprName(arrayObj.len, opts);
-                      if (opts.wantHtml) {
-                          name += '' + lenName + '';
-                      } else {
-                          name += lenName;
-                      }
-                      name += "]";
-                      name += exprName(arrayObj.child, opts);
-                      return name;
+                    let arrayObj = /** @type {ArrayType} */ (typeObj);
+                    let name = "[";
+                    let lenName = exprName(arrayObj.len, opts);
+                    let sentinel = arrayObj.sentinel !== null ? ":"+arrayObj.sentinel : "";
+
+                    if (opts.wantHtml) {
+                      name +=
+                        '' + lenName + sentinel + "";
+                    } else {
+                      name += lenName;
+                    }
+                    name += "]";
+                    name += exprName(arrayObj.child, opts);
+                    return name;
                   }
                   case typeKinds.Optional:
                       return "?" + exprName(/**@type {OptionalType} */(typeObj).child, opts);
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index efd9d1f4db..0de13ea2e2 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -773,6 +773,7 @@ fn walkInstruction(
                 });
                 break :blk .{ .type = ptrTypeId };
             };
+
             return DocData.WalkResult{
                 .typeRef = tRef,
                 .expr = .{ .string = str },
@@ -817,7 +818,6 @@ fn walkInstruction(
         },
         .elem_type => {
             const un_node = data[inst_index].un_node;
-            std.debug.print("un_node: {}\n", .{un_node});
 
             var operand: DocData.WalkResult = try self.walkRef(
                 file,
@@ -826,8 +826,6 @@ fn walkInstruction(
                 false,
             );
 
-            std.debug.print("operand: {}\n", .{operand});
-
             return DocData.WalkResult{
                 .typeRef = .{ .type = operand.typeRef.?.type },
                 .expr = .{ .type = operand.expr.type },
@@ -853,14 +851,8 @@ fn walkInstruction(
             const ptr = data[inst_index].ptr_type;
             const extra = file.zir.extraData(Zir.Inst.PtrType, ptr.payload_index);
 
-            std.debug.print("ptr = {}\n", .{ptr});
-            std.debug.print("extra = {any}\n", .{extra});
-
             const sentinel: ?usize = if (ptr.flags.has_sentinel) 0 else null;
 
-            std.debug.print("sentinel = {} {d}\n", .{ ptr.flags.has_sentinel, sentinel });
-            std.debug.print("type = {d}\n", .{@enumToInt(Ref.type_type)});
-
             const type_slot_index = self.types.items.len;
             const elem_type_ref = try self.walkRef(
                 file,
@@ -875,7 +867,6 @@ fn walkInstruction(
                     .sentinel = sentinel,
                 },
             });
-            std.debug.print("type = {d}\n", .{type_slot_index});
             return DocData.WalkResult{
                 // .typeRef = .{ .type = type_slot_index },
                 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
@@ -887,11 +878,6 @@ fn walkInstruction(
             const len = try self.walkRef(file, parent_scope, bin.lhs, false);
             const child = try self.walkRef(file, parent_scope, bin.rhs, false);
 
-            std.debug.print("AEHO\n", .{});
-            // std.debug.print("bin = {}\n", .{bin});
-            // std.debug.print("len = {}\n", .{len});
-            // std.debug.print("child = {}\n", .{child});
-
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
                 .Array = .{
@@ -899,6 +885,7 @@ fn walkInstruction(
                     .child = child.expr,
                 },
             });
+
             return DocData.WalkResult{
                 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
                 .expr = .{ .type = type_slot_index },
@@ -908,7 +895,7 @@ fn walkInstruction(
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.ArrayTypeSentinel, pl_node.payload_index);
             const len = try self.walkRef(file, parent_scope, extra.data.len, false);
-            const sentinel = try self.walkRef(file, parent_scope, extra.data.sentinel, false);
+            // const sentinel = try self.walkRef(file, parent_scope, extra.data.sentinel, false);
             const elem_type = try self.walkRef(file, parent_scope, extra.data.elem_type, false);
 
             const type_slot_index = self.types.items.len;
@@ -916,7 +903,7 @@ fn walkInstruction(
                 .Array = .{
                     .len = len.expr,
                     .child = elem_type.expr,
-                    .sentinel = sentinel.expr.int.value,
+                    .sentinel = 0,
                 },
             });
             return DocData.WalkResult{
@@ -938,7 +925,6 @@ fn walkInstruction(
                 // we only ask to figure out type info for the first element
                 // as it will be used later on to find out the array type!
                 const wr = try self.walkRef(file, parent_scope, op, idx == 0);
-                std.debug.print("wr: {any}\n", .{wr});
 
                 if (idx == 0) {
                     array_type = wr.typeRef;
@@ -979,7 +965,6 @@ fn walkInstruction(
                 // we only ask to figure out type info for the first element
                 // as it will be used later on to find out the array type!
                 const wr = try self.walkRef(file, parent_scope, op, idx == 0);
-                std.debug.print("wr: {any}\n", .{wr});
                 if (idx == 0) {
                     array_type = wr.typeRef;
                 }
@@ -990,8 +975,6 @@ fn walkInstruction(
                 array_data[idx] = wr.expr.as.exprArg;
             }
 
-            // std.debug.print("array: {any}\n", .{array_data});
-
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
                 .Array = .{ .len = .{
@@ -1016,20 +999,15 @@ fn walkInstruction(
             // TODO: make sure that you want the array to be fully normalized for real
             // then update this code to conform to your choice.
 
-            // std.debug.print("extra: {}\n", .{extra});
-            // std.debug.print("operands: {any}\n", .{operands});
-
             var array_type: ?DocData.Expr = null;
             for (operands) |op, idx| {
                 // we only ask to figure out type info for the first element
                 // as it will be used later on to find out the array type!
                 const wr = try self.walkRef(file, parent_scope, op, idx == 0);
-                // std.debug.print("wr: {any}\n", .{wr});
 
                 if (idx == 0) {
                     array_type = wr.typeRef;
                 }
-                // std.debug.print("type: {}\n", .{@intToEnum(Ref, wr.typeRef.?.type)});
 
                 // create an untion to hold more than one type
                 switch (@intToEnum(Ref, wr.typeRef.?.type)) {
@@ -1044,8 +1022,6 @@ fn walkInstruction(
                 }
             }
 
-            // std.debug.print("array: {any}\n", .{array_data});
-
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
                 .Array = .{
@@ -1064,20 +1040,6 @@ fn walkInstruction(
                 .expr = .{ .array = array_data },
             };
         },
-        // .validate_array_init_ty => {
-        //     const un_node = data[inst_index].un_node;
-        //     var operand: DocData.WalkResult = try self.walkRef(
-        //         file,
-        //         parent_scope,
-        //         un_node.operand,
-        //         need_type,
-        //     );
-        //
-        //     std.debug.print("validate _ array => {}\n", .{un_node});
-        //     std.debug.print("operand = {}\n", .{operand});
-        //
-        //     return operand;
-        // },
         .float => {
             const float = data[inst_index].float;
             return DocData.WalkResult{

From 5b20b1f2a71392ccac0afd582bbcbc974846bac3 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Mon, 23 May 2022 14:28:49 -0300
Subject: [PATCH 057/137] add: array init refs

---
 src/Autodoc.zig | 91 ++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 90 insertions(+), 1 deletion(-)

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 0de13ea2e2..50500412e2 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -843,7 +843,7 @@ fn walkInstruction(
             });
 
             return DocData.WalkResult{
-                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .typeRef = .{ .type = elem_type_ref.expr.type },
                 .expr = .{ .type = type_slot_index },
             };
         },
@@ -1040,6 +1040,94 @@ fn walkInstruction(
                 .expr = .{ .array = array_data },
             };
         },
+        .array_init_ref => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.MultiOp, pl_node.payload_index);
+            const operands = file.zir.refSlice(extra.end, extra.data.operands_len);
+            const array_data = try self.arena.alloc(usize, operands.len);
+
+            var array_type: ?DocData.Expr = null;
+            for (operands) |op, idx| {
+                const wr = try self.walkRef(file, parent_scope, op, idx == 0);
+                if (idx == 0) {
+                    array_type = wr.typeRef;
+                }
+                array_data[idx] = wr.expr.as.exprArg;
+            }
+
+            const type_slot_index = self.types.items.len;
+            try self.types.append(self.arena, .{ .Pointer = .{
+                .size = .One,
+                .child = array_type.?,
+            } });
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = type_slot_index },
+                .expr = .{ .array = array_data },
+            };
+        },
+        .array_init_sent_ref => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.MultiOp, pl_node.payload_index);
+            // the sentinel terminator are calculated at compile time
+            // (extra.data.operands_len - 1) is to not account for that
+            const operands = file.zir.refSlice(extra.end, extra.data.operands_len - 1);
+            const array_data = try self.arena.alloc(usize, operands.len);
+
+            var array_type: ?DocData.Expr = null;
+            for (operands) |op, idx| {
+                const wr = try self.walkRef(file, parent_scope, op, idx == 0);
+                if (idx == 0) {
+                    array_type = wr.typeRef;
+                }
+                array_data[idx] = wr.expr.as.exprArg;
+            }
+
+            const type_slot_index = self.types.items.len;
+            try self.types.append(self.arena, .{
+                .Array = .{ .len = .{
+                    .int = .{
+                        .value = operands.len,
+                        .negated = false,
+                    },
+                }, .child = array_type.?, .sentinel = 0 },
+            });
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = type_slot_index },
+                .expr = .{ .array = array_data },
+            };
+        },
+        .array_init_anon_ref => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.MultiOp, pl_node.payload_index);
+            const operands = file.zir.refSlice(extra.end, extra.data.operands_len);
+            const array_data = try self.arena.alloc(usize, operands.len);
+
+            var array_type: ?DocData.Expr = null;
+            for (operands) |op, idx| {
+                const wr = try self.walkRef(file, parent_scope, op, idx == 0);
+                if (idx == 0) {
+                    array_type = wr.typeRef;
+                }
+                array_data[idx] = wr.expr.int.value;
+            }
+
+            const type_slot_index = self.types.items.len;
+            try self.types.append(self.arena, .{
+                .Array = .{ .len = .{
+                    .int = .{
+                        .value = operands.len,
+                        .negated = false,
+                    },
+                }, .child = array_type.? },
+            });
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = type_slot_index },
+                .expr = .{ .array = array_data },
+            };
+        },
         .float => {
             const float = data[inst_index].float;
             return DocData.WalkResult{
@@ -1116,6 +1204,7 @@ fn walkInstruction(
                 extra.data.operand,
                 false,
             );
+
             const operand_idx = self.exprs.items.len;
             try self.exprs.append(self.arena, operand.expr);
 

From 019fd456175daf6111dcb6cb265dbb9dc50aebfc Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Mon, 23 May 2022 18:58:51 -0300
Subject: [PATCH 058/137] fix: sentinel working with types and in fn decls

---
 lib/docs/main.js | 17 ++++++++++++-----
 src/Autodoc.zig  | 15 ++++++++-------
 2 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 4e78b760b3..befa858304 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1133,13 +1133,13 @@ var zigAnalysis;
                     let arrayObj = /** @type {ArrayType} */ (typeObj);
                     let name = "[";
                     let lenName = exprName(arrayObj.len, opts);
-                    let sentinel = arrayObj.sentinel !== null ? ":"+arrayObj.sentinel : "";
+                    let sentinel = arrayObj.sentinel ? ":0" : "";
 
                     if (opts.wantHtml) {
                       name +=
                         '' + lenName + sentinel + "";
                     } else {
-                      name += lenName;
+                      name += lenName + sentinel;
                     }
                     name += "]";
                     name += exprName(arrayObj.child, opts);
@@ -1150,6 +1150,7 @@ var zigAnalysis;
                   case typeKinds.Pointer:
                   {
                       let ptrObj = /** @type {PointerType} */(typeObj);
+                      let sentinel = ptrObj.sentinel ? ":0" : "";
                       let name = "";
                       switch (ptrObj.size) {
                           default:
@@ -1158,13 +1159,19 @@ var zigAnalysis;
                               name += "*";
                               break;
                           case pointerSizeEnum.Many:
-                              name += "[*]";
+                              name += "[*";
+                              name += sentinel;
+                              name += "]";
                               break;
                           case pointerSizeEnum.Slice:
-                              name += "[]";
+                              name += "[";
+                              name += sentinel;
+                              name += "]";
                               break;
                           case pointerSizeEnum.C:
-                              name += "[*c]";
+                              name += "[*c";
+                              name += sentinel;
+                              name += "]";
                               break;
                       }
                       if (ptrObj['const']) {
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 50500412e2..efae96b3bb 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -383,12 +383,12 @@ const DocData = struct {
         Pointer: struct {
             size: std.builtin.TypeInfo.Pointer.Size,
             child: Expr,
-            sentinel: ?usize = null,
+            sentinel: bool = false,
         },
         Array: struct {
             len: Expr,
             child: Expr,
-            sentinel: ?usize = null,
+            sentinel: bool = false,
         },
         Struct: struct {
             name: []const u8,
@@ -767,7 +767,7 @@ fn walkInstruction(
                     .Pointer = .{
                         .size = .One,
                         .child = .{ .type = arrTypeId },
-                        .sentinel = 0,
+                        .sentinel = true,
                         // TODO: add sentinel!
                     },
                 });
@@ -851,7 +851,7 @@ fn walkInstruction(
             const ptr = data[inst_index].ptr_type;
             const extra = file.zir.extraData(Zir.Inst.PtrType, ptr.payload_index);
 
-            const sentinel: ?usize = if (ptr.flags.has_sentinel) 0 else null;
+            const sentinel: bool = if (ptr.flags.has_sentinel) true else false;
 
             const type_slot_index = self.types.items.len;
             const elem_type_ref = try self.walkRef(
@@ -903,7 +903,7 @@ fn walkInstruction(
                 .Array = .{
                     .len = len.expr,
                     .child = elem_type.expr,
-                    .sentinel = 0,
+                    .sentinel = true,
                 },
             });
             return DocData.WalkResult{
@@ -982,7 +982,7 @@ fn walkInstruction(
                         .value = operands.len,
                         .negated = false,
                     },
-                }, .child = array_type.?, .sentinel = 0 },
+                }, .child = array_type.?, .sentinel = true },
             });
 
             return DocData.WalkResult{
@@ -1090,7 +1090,7 @@ fn walkInstruction(
                         .value = operands.len,
                         .negated = false,
                     },
-                }, .child = array_type.?, .sentinel = 0 },
+                }, .child = array_type.?, .sentinel = true },
             });
 
             return DocData.WalkResult{
@@ -1312,6 +1312,7 @@ fn walkInstruction(
             try self.types.append(self.arena, .{
                 .Int = .{ .name = name },
             });
+
             return DocData.WalkResult{
                 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
                 .expr = .{ .type = self.types.items.len - 1 },

From 21fd4a7a8b100cfb35a67f66bd9887006978ed60 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Mon, 23 May 2022 20:24:16 -0300
Subject: [PATCH 059/137] fix: printing const in types and fn decl and sentinel
 in strings

---
 lib/docs/main.js |  7 +++++++
 src/Autodoc.zig  | 19 +++++++++++--------
 2 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index befa858304..e436b9859e 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1134,6 +1134,7 @@ var zigAnalysis;
                     let name = "[";
                     let lenName = exprName(arrayObj.len, opts);
                     let sentinel = arrayObj.sentinel ? ":0" : "";
+                    let is_mutable = arrayObj.is_multable ? "const " : "";
 
                     if (opts.wantHtml) {
                       name +=
@@ -1142,6 +1143,7 @@ var zigAnalysis;
                       name += lenName + sentinel;
                     }
                     name += "]";
+                    name += is_mutable;
                     name += exprName(arrayObj.child, opts);
                     return name;
                   }
@@ -1151,27 +1153,32 @@ var zigAnalysis;
                   {
                       let ptrObj = /** @type {PointerType} */(typeObj);
                       let sentinel = ptrObj.sentinel ? ":0" : "";
+                      let is_mutable = !ptrObj.is_mutable ? "const " : "";
                       let name = "";
                       switch (ptrObj.size) {
                           default:
                               console.log("TODO: implement unhandled pointer size case");
                           case pointerSizeEnum.One:
                               name += "*";
+                              name += is_mutable;
                               break;
                           case pointerSizeEnum.Many:
                               name += "[*";
                               name += sentinel;
                               name += "]";
+                              name += is_mutable;
                               break;
                           case pointerSizeEnum.Slice:
                               name += "[";
                               name += sentinel;
                               name += "]";
+                              name += is_mutable;
                               break;
                           case pointerSizeEnum.C:
                               name += "[*c";
                               name += sentinel;
                               name += "]";
+                              name += is_mutable;
                               break;
                       }
                       if (ptrObj['const']) {
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index efae96b3bb..15d4ea45d2 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -384,6 +384,7 @@ const DocData = struct {
             size: std.builtin.TypeInfo.Pointer.Size,
             child: Expr,
             sentinel: bool = false,
+            is_mutable: bool = true,
         },
         Array: struct {
             len: Expr,
@@ -485,6 +486,11 @@ const DocData = struct {
                         \\
                     , .{v.sentinel});
                     if (options.whitespace) |ws| try ws.outputIndent(w);
+                    try w.print(
+                        \\"is_mutable": {},
+                        \\
+                    , .{v.is_mutable});
+                    if (options.whitespace) |ws| try ws.outputIndent(w);
                     try w.print(
                         \\"child":
                     , .{});
@@ -759,6 +765,7 @@ fn walkInstruction(
                     .Array = .{
                         .len = .{ .int = .{ .value = str.len } },
                         .child = .{ .type = @enumToInt(Ref.u8_type) },
+                        .sentinel = true,
                     },
                 });
                 // const sentinel: ?usize = if (ptr.flags.has_sentinel) 0 else null;
@@ -768,7 +775,7 @@ fn walkInstruction(
                         .size = .One,
                         .child = .{ .type = arrTypeId },
                         .sentinel = true,
-                        // TODO: add sentinel!
+                        .is_mutable = false,
                     },
                 });
                 break :blk .{ .type = ptrTypeId };
@@ -839,11 +846,12 @@ fn walkInstruction(
                 .Pointer = .{
                     .size = ptr.size,
                     .child = elem_type_ref.expr,
+                    .is_mutable = ptr.is_mutable,
                 },
             });
 
             return DocData.WalkResult{
-                .typeRef = .{ .type = elem_type_ref.expr.type },
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
                 .expr = .{ .type = type_slot_index },
             };
         },
@@ -861,14 +869,9 @@ fn walkInstruction(
                 false,
             );
             try self.types.append(self.arena, .{
-                .Pointer = .{
-                    .size = ptr.size,
-                    .child = elem_type_ref.expr,
-                    .sentinel = sentinel,
-                },
+                .Pointer = .{ .size = ptr.size, .child = elem_type_ref.expr, .sentinel = sentinel, .is_mutable = ptr.flags.is_mutable },
             });
             return DocData.WalkResult{
-                // .typeRef = .{ .type = type_slot_index },
                 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
                 .expr = .{ .type = type_slot_index },
             };

From bde1caa4ceecb976e728c04c5aebb34f260d9b70 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Tue, 24 May 2022 00:10:59 -0300
Subject: [PATCH 060/137] fix: array_init_anon know working

---
 src/Autodoc.zig | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 15d4ea45d2..c1d273eecc 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -1007,22 +1007,16 @@ fn walkInstruction(
                 // we only ask to figure out type info for the first element
                 // as it will be used later on to find out the array type!
                 const wr = try self.walkRef(file, parent_scope, op, idx == 0);
-
                 if (idx == 0) {
                     array_type = wr.typeRef;
                 }
 
-                // create an untion to hold more than one type
-                switch (@intToEnum(Ref, wr.typeRef.?.type)) {
-                    .comptime_int_type => {
-                        array_data[idx] = wr.expr.int.value;
-                    },
-                    .comptime_float_type => {
-                        unreachable;
-                        // array_data[idx] = wr.expr.float;
-                    },
-                    else => continue,
-                }
+                // array_init_anon doesn't have the elements in @as nodes
+                // so it's necessary append them to expr array
+                // and remember their positions
+                const expr_index = self.exprs.items.len;
+                try self.exprs.append(self.arena, wr.expr);
+                array_data[idx] = expr_index;
             }
 
             const type_slot_index = self.types.items.len;

From d707cd6e6df0aca14a9faaf2b411b3c4a3f08d10 Mon Sep 17 00:00:00 2001
From: Loris Cro 
Date: Tue, 24 May 2022 18:03:04 +0200
Subject: [PATCH 061/137] autodoc: improve decl categorization and fix
 enumliteral arrays/ptrs

---
 lib/docs/main.js | 42 +++++++++++++++++++++++++++++-------------
 src/Autodoc.zig  | 20 +++++++++++++++++++-
 2 files changed, 48 insertions(+), 14 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index e436b9859e..f33bdfad54 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1045,7 +1045,11 @@ var zigAnalysis;
     */
     function walkResultTypeRef(wr) {
       if (wr.typeRef) return wr.typeRef;
-      return walkResultTypeRef(resolveValue(wr));
+      let resolved = resolveValue(wr);
+      if (wr === resolved) {
+        return {type: 0};
+      }
+      return walkResultTypeRef(resolved);
     }
      /**
       * @typedef {{
@@ -1128,6 +1132,10 @@ var zigAnalysis;
 
               switch (typeObj.kind) {
                   default: throw "TODO";
+                  case typeKinds.ComptimeExpr:
+                  {
+                      return "[ComptimeExpr]";
+                  }
                   case typeKinds.Array:
                   {
                     let arrayObj = /** @type {ArrayType} */ (typeObj);
@@ -1660,7 +1668,7 @@ var zigAnalysis;
                         const funcRetExpr = resolveValue({
                             expr: /** @type {Fn} */(typeExpr).ret
                         });
-                        if ("type" in funcRetExpr && funcRetExpr.type != typeTypeId) {
+                        if ("type" in funcRetExpr.expr && funcRetExpr.expr.type == typeTypeId) {
                             if (typeIsErrSet(declValue.expr.type)) {
                                 errSetsList.push(decl);
                             } else if (typeIsStructWithNoFields(declValue.expr.type)) {
@@ -1671,9 +1679,15 @@ var zigAnalysis;
                         } else {
                             fnsList.push(decl);
                         }
-                     } else {
-                        typesList.push(decl);
-                     }
+                    } else {
+                        if (typeIsErrSet(declValue.expr.type)) {
+                            errSetsList.push(decl);
+                        } else if (typeIsStructWithNoFields(declValue.expr.type)) {
+                            namespacesList.push(decl);
+                        } else {
+                            typesList.push(decl);
+                        }
+                    }
                  } else if ("typeRef" in declValue) {
                       if ("type" in declValue.typeRef && declValue.typeRef == typeTypeId) {
                           // We don't know what the type expression is, but we know it's a type.
@@ -2098,14 +2112,14 @@ var zigAnalysis;
                         if (list[mainDeclIndex] != null) continue;
 
                         let decl = zigAnalysis.decls[mainDeclIndex];
-                        let declVal = resolveValue(decl.value);
+                        let declVal =  decl.value; //resolveValue(decl.value);
                         let declNames = item.declNames.concat([decl.name]);
                         list[mainDeclIndex] = {
                             pkgNames: pkgNames,
                             declNames: declNames,
                         };
-                        if ("type" in declVal) {
-                            let value = zigAnalysis.types[declVal.type];
+                        if ("type" in declVal.expr) {
+                            let value = zigAnalysis.types[declVal.expr.type];
                             if (declCanRepresentTypeKind(value.kind))
                             {
                                 canonTypeDecls[declVal.type] = mainDeclIndex;
@@ -2130,15 +2144,15 @@ var zigAnalysis;
         if (canonDeclPaths == null) {
             canonDeclPaths = computeCanonDeclPaths();
         }
-        let cd = /** @type {CanonDecl[]}*/(canonDeclPaths);
-        return cd[index];
+        //let cd = /** @type {CanonDecl[]}*/(canonDeclPaths);
+        return canonDeclPaths[index];
     }
 
     /** @param {number} index */
     function getCanonTypeDecl(index) {
         getCanonDeclPath(0);
-        let ct = /** @type {number[]}*/(canonTypeDecls);
-        return ct[index];
+        //let ct = /** @type {number[]}*/(canonTypeDecls);
+        return canonTypeDecls[index];
     }
 
     /** @param {string} text */
@@ -2646,7 +2660,9 @@ function renderSearch() {
         let lastPkgName = canonPath.pkgNames[canonPath.pkgNames.length - 1];
         let fullPathSearchText = lastPkgName + "." + canonPath.declNames.join('.');
         let astNode = zigAnalysis.astNodes[decl.src];
-        let fileAndDocs = zigAnalysis.files[astNode.file];
+        let fileAndDocs = "" //zigAnalysis.files[astNode.file];
+        // TODO: understand what this piece of code is trying to achieve
+        //       also right now `files` are expressed as a hashmap.
         if (astNode.docs != null) {
             fileAndDocs += "\n" + astNode.docs;
         }
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index c1d273eecc..d16b481a65 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -474,6 +474,7 @@ const DocData = struct {
                 .Int => |v| try printTypeBody(v, options, w),
                 .Float => |v| try printTypeBody(v, options, w),
                 .Type => |v| try printTypeBody(v, options, w),
+                .EnumLiteral => |v| try printTypeBody(v, options, w),
                 .Pointer => |v| {
                     if (options.whitespace) |ws| try ws.outputIndent(w);
                     try w.print(
@@ -807,7 +808,15 @@ fn walkInstruction(
         .enum_literal => {
             const str_tok = data[inst_index].str_tok;
             const literal = file.zir.nullTerminatedString(str_tok.start);
-            return DocData.WalkResult{ .expr = .{ .enumLiteral = literal } };
+            const type_index = self.types.items.len;
+            try self.types.append(self.arena, .{
+                .EnumLiteral = .{ .name = "todo enum literal" },
+            });
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = type_index },
+                .expr = .{ .enumLiteral = literal },
+            };
         },
         .int => {
             const int = data[inst_index].int;
@@ -1019,6 +1028,15 @@ fn walkInstruction(
                 array_data[idx] = expr_index;
             }
 
+            if (array_type == null) {
+                panicWithContext(
+                    file,
+                    inst_index,
+                    "array_type was null!!",
+                    .{},
+                );
+            }
+
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
                 .Array = .{

From 2a3fb341aa4e4603774289627c8eb397fdc854d1 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Tue, 24 May 2022 22:14:05 -0300
Subject: [PATCH 062/137] fix: handling more types of sentinels. now can be
 structs too

---
 lib/docs/main.js | 28 +++++++++++++-
 src/Autodoc.zig  | 98 +++++++++++++++++++++++++++++-------------------
 2 files changed, 86 insertions(+), 40 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index f33bdfad54..346681b200 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1062,6 +1062,30 @@ var zigAnalysis;
     function exprName(expr, opts) {
         switch (Object.keys(expr)[0]) {
           default: throw "oh no";
+          case "struct": {
+            const struct_name = zigAnalysis.decls[expr.struct[0].val.typeRef.refPath[0].declRef].name;
+            let struct_body = "";
+            struct_body += struct_name + "{ ";
+            for (let i = 0; i < expr.struct.length; i++) {
+              const val = expr.struct[i].name
+              const exprArg = zigAnalysis.exprs[expr.struct[i].val.expr.as.exprArg];
+              let value_field = exprArg[Object.keys(exprArg)[0]];
+              if (value_field instanceof Object) {
+                value_field = zigAnalysis.decls[value_field[0].val.typeRef.refPath[0].declRef].name;
+              };
+              struct_body += "." + val + " = " + value_field;
+              if (i !== expr.struct.length - 1) {
+                struct_body += ", ";
+              }  else {
+                struct_body += " ";
+              }
+            }
+              struct_body += "}";
+            return struct_body;
+          }
+          case "null": {
+            return "null";
+          }
           case "array": {
             let payloadHtml = ".{";
             for (let i = 0; i < expr.array.length; i++) {
@@ -1141,7 +1165,7 @@ var zigAnalysis;
                     let arrayObj = /** @type {ArrayType} */ (typeObj);
                     let name = "[";
                     let lenName = exprName(arrayObj.len, opts);
-                    let sentinel = arrayObj.sentinel ? ":0" : "";
+                    let sentinel = arrayObj.sentinel ? ":"+exprName(arrayObj.sentinel, opts) : "";
                     let is_mutable = arrayObj.is_multable ? "const " : "";
 
                     if (opts.wantHtml) {
@@ -1160,7 +1184,7 @@ var zigAnalysis;
                   case typeKinds.Pointer:
                   {
                       let ptrObj = /** @type {PointerType} */(typeObj);
-                      let sentinel = ptrObj.sentinel ? ":0" : "";
+                    let sentinel = ptrObj.sentinel ? ":"+exprName(ptrObj.sentinel, opts) : "";
                       let is_mutable = !ptrObj.is_mutable ? "const " : "";
                       let name = "";
                       switch (ptrObj.size) {
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index d16b481a65..e5f95bfade 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -383,13 +383,13 @@ const DocData = struct {
         Pointer: struct {
             size: std.builtin.TypeInfo.Pointer.Size,
             child: Expr,
-            sentinel: bool = false,
+            sentinel: ?Expr = null,
             is_mutable: bool = true,
         },
         Array: struct {
             len: Expr,
             child: Expr,
-            sentinel: bool = false,
+            sentinel: ?Expr = null,
         },
         Struct: struct {
             name: []const u8,
@@ -482,11 +482,14 @@ const DocData = struct {
                         \\
                     , .{@enumToInt(v.size)});
                     if (options.whitespace) |ws| try ws.outputIndent(w);
-                    try w.print(
-                        \\"sentinel": {},
-                        \\
-                    , .{v.sentinel});
-                    if (options.whitespace) |ws| try ws.outputIndent(w);
+                    if (v.sentinel) |sentinel| {
+                        try w.print(
+                            \\"sentinel":
+                        , .{});
+                        if (options.whitespace) |*ws| ws.indent_level += 1;
+                        try sentinel.jsonStringify(options, w);
+                        try w.print(",", .{});
+                    }
                     try w.print(
                         \\"is_mutable": {},
                         \\
@@ -766,7 +769,10 @@ fn walkInstruction(
                     .Array = .{
                         .len = .{ .int = .{ .value = str.len } },
                         .child = .{ .type = @enumToInt(Ref.u8_type) },
-                        .sentinel = true,
+                        .sentinel = .{ .int = .{
+                            .value = 0,
+                            .negated = false,
+                        } },
                     },
                 });
                 // const sentinel: ?usize = if (ptr.flags.has_sentinel) 0 else null;
@@ -775,7 +781,10 @@ fn walkInstruction(
                     .Pointer = .{
                         .size = .One,
                         .child = .{ .type = arrTypeId },
-                        .sentinel = true,
+                        .sentinel = .{ .int = .{
+                            .value = 0,
+                            .negated = false,
+                        } },
                         .is_mutable = false,
                     },
                 });
@@ -842,10 +851,7 @@ fn walkInstruction(
                 false,
             );
 
-            return DocData.WalkResult{
-                .typeRef = .{ .type = operand.typeRef.?.type },
-                .expr = .{ .type = operand.expr.type },
-            };
+            return operand;
         },
         .ptr_type_simple => {
             const ptr = data[inst_index].ptr_type_simple;
@@ -868,8 +874,6 @@ fn walkInstruction(
             const ptr = data[inst_index].ptr_type;
             const extra = file.zir.extraData(Zir.Inst.PtrType, ptr.payload_index);
 
-            const sentinel: bool = if (ptr.flags.has_sentinel) true else false;
-
             const type_slot_index = self.types.items.len;
             const elem_type_ref = try self.walkRef(
                 file,
@@ -877,8 +881,9 @@ fn walkInstruction(
                 extra.data.elem_type,
                 false,
             );
+
             try self.types.append(self.arena, .{
-                .Pointer = .{ .size = ptr.size, .child = elem_type_ref.expr, .sentinel = sentinel, .is_mutable = ptr.flags.is_mutable },
+                .Pointer = .{ .size = ptr.size, .child = elem_type_ref.expr, .sentinel = .{ .int = .{ .value = 0, .negated = false } }, .is_mutable = ptr.flags.is_mutable },
             });
             return DocData.WalkResult{
                 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
@@ -907,7 +912,7 @@ fn walkInstruction(
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.ArrayTypeSentinel, pl_node.payload_index);
             const len = try self.walkRef(file, parent_scope, extra.data.len, false);
-            // const sentinel = try self.walkRef(file, parent_scope, extra.data.sentinel, false);
+            const sentinel = try self.walkRef(file, parent_scope, extra.data.sentinel, false);
             const elem_type = try self.walkRef(file, parent_scope, extra.data.elem_type, false);
 
             const type_slot_index = self.types.items.len;
@@ -915,7 +920,7 @@ fn walkInstruction(
                 .Array = .{
                     .len = len.expr,
                     .child = elem_type.expr,
-                    .sentinel = true,
+                    .sentinel = sentinel.expr,
                 },
             });
             return DocData.WalkResult{
@@ -966,12 +971,12 @@ fn walkInstruction(
         .array_init_sent => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.MultiOp, pl_node.payload_index);
-            const operands = file.zir.refSlice(extra.end, extra.data.operands_len - 1);
-            const array_data = try self.arena.alloc(usize, operands.len);
+            const operands = file.zir.refSlice(extra.end, extra.data.operands_len);
+            const array_data = try self.arena.alloc(usize, operands.len - 1);
 
             // TODO: make sure that you want the array to be fully normalized for real
             // then update this code to conform to your choice.
-
+            var sentinel: ?DocData.Expr = null;
             var array_type: ?DocData.Expr = null;
             for (operands) |op, idx| {
                 // we only ask to figure out type info for the first element
@@ -981,20 +986,21 @@ fn walkInstruction(
                     array_type = wr.typeRef;
                 }
 
-                // We know that Zir wraps every operand in an @as expression
-                // so we want to peel it away and only save the target type
-                // once, since we need it later to define the array type.
-                array_data[idx] = wr.expr.as.exprArg;
+                if (idx == extra.data.operands_len - 1) {
+                    sentinel = self.exprs.items[wr.expr.as.exprArg];
+                } else {
+                    array_data[idx] = wr.expr.as.exprArg;
+                }
             }
 
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
                 .Array = .{ .len = .{
                     .int = .{
-                        .value = operands.len,
+                        .value = operands.len - 1,
                         .negated = false,
                     },
-                }, .child = array_type.?, .sentinel = true },
+                }, .child = array_type.?, .sentinel = sentinel },
             });
 
             return DocData.WalkResult{
@@ -1084,28 +1090,36 @@ fn walkInstruction(
         .array_init_sent_ref => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.MultiOp, pl_node.payload_index);
-            // the sentinel terminator are calculated at compile time
-            // (extra.data.operands_len - 1) is to not account for that
-            const operands = file.zir.refSlice(extra.end, extra.data.operands_len - 1);
-            const array_data = try self.arena.alloc(usize, operands.len);
+            const operands = file.zir.refSlice(extra.end, extra.data.operands_len);
+            const array_data = try self.arena.alloc(usize, operands.len - 1);
 
+            // TODO: This should output:
+            // const array: *[value:sentinel]type = &.{};
+            // but right now it's printing:
+            // const array: [value:sentinel]u8 = .{};
+
+            var sentinel: ?DocData.Expr = null;
             var array_type: ?DocData.Expr = null;
             for (operands) |op, idx| {
                 const wr = try self.walkRef(file, parent_scope, op, idx == 0);
                 if (idx == 0) {
                     array_type = wr.typeRef;
                 }
-                array_data[idx] = wr.expr.as.exprArg;
+                if (idx == extra.data.operands_len - 1) {
+                    sentinel = self.exprs.items[wr.expr.as.exprArg];
+                } else {
+                    array_data[idx] = wr.expr.as.exprArg;
+                }
             }
 
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
                 .Array = .{ .len = .{
                     .int = .{
-                        .value = operands.len,
+                        .value = operands.len - 1,
                         .negated = false,
                     },
-                }, .child = array_type.?, .sentinel = true },
+                }, .child = array_type.?, .sentinel = sentinel },
             });
 
             return DocData.WalkResult{
@@ -1117,7 +1131,9 @@ fn walkInstruction(
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.MultiOp, pl_node.payload_index);
             const operands = file.zir.refSlice(extra.end, extra.data.operands_len);
-            const array_data = try self.arena.alloc(usize, operands.len);
+            const array_data = try self.arena.alloc(usize, operands.len - 1);
+
+            var sentinel: ?DocData.Expr = null;
 
             var array_type: ?DocData.Expr = null;
             for (operands) |op, idx| {
@@ -1125,17 +1141,23 @@ fn walkInstruction(
                 if (idx == 0) {
                     array_type = wr.typeRef;
                 }
-                array_data[idx] = wr.expr.int.value;
+
+                if (idx == extra.data.operands_len - 1) {
+                    sentinel = wr.expr;
+                    const expr_index = self.exprs.items.len;
+                    try self.exprs.append(self.arena, wr.expr);
+                    array_data[idx] = expr_index;
+                }
             }
 
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
                 .Array = .{ .len = .{
                     .int = .{
-                        .value = operands.len,
+                        .value = operands.len - 1,
                         .negated = false,
                     },
-                }, .child = array_type.? },
+                }, .child = array_type.?, .sentinel = sentinel },
             });
 
             return DocData.WalkResult{

From 4da1f1fb323c2980dae715ae49e7fff80a1dc46a Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Wed, 25 May 2022 01:42:40 -0300
Subject: [PATCH 063/137] add: handling comptimeExpr in js

---
 lib/docs/main.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 346681b200..c024ef65ce 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1096,7 +1096,7 @@ var zigAnalysis;
             return payloadHtml + "}";
           }
           case "comptimeExpr": {
-              return "[ComptimeExpr]";
+              return zigAnalysis.comptimeExprs[expr.comptimeExpr].code;
           }
           case "call": {
               let call = zigAnalysis.calls[expr.call];

From 7b11c23da6b19be8c6dafb54bb1a0a0b26ca4938 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Wed, 25 May 2022 03:00:40 -0300
Subject: [PATCH 064/137] fix: comptimeExpr working with generated data

---
 lib/docs/main.js | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index c024ef65ce..7c151ad588 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1158,7 +1158,10 @@ var zigAnalysis;
                   default: throw "TODO";
                   case typeKinds.ComptimeExpr:
                   {
-                      return "[ComptimeExpr]";
+                      // trying to match the std lib types
+                      // the *[1]anyopaque behavior it's happening
+                      // because of the known issue with arrays and pointers
+                      return "anyopaque";
                   }
                   case typeKinds.Array:
                   {
@@ -1443,10 +1446,11 @@ var zigAnalysis;
                                       });
                                       payloadHtml += '' + escapeHtml(name) + '';
                                   } else if ("comptimeExpr" in value) {
+                                      let comptimeExpr = zigAnalysis.comptimeExprs[value.comptimeExpr].code;
                                       if (opts.wantHtml) {
-                                        payloadHtml += '[ComptimeExpr]';
+                                        payloadHtml += '' + comptimeExpr + '';
                                       } else {
-                                        payloadHtml += "[ComptimeExpr]";
+                                        payloadHtml += comptimeExpr;
                                       }
                                   } else if (opts.wantHtml) {
                                       payloadHtml += 'anytype';

From cadee07ef41a108a0bf0592c9ed6ab5914fa231d Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Wed, 25 May 2022 14:35:27 -0300
Subject: [PATCH 065/137] fix: paths working on windows

---
 src/Autodoc.zig | 25 +++++++++++++++++++++----
 1 file changed, 21 insertions(+), 4 deletions(-)

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index e5f95bfade..db462dea92 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -292,10 +292,27 @@ const DocData = struct {
             if (options.whitespace) |*ws| ws.indent_level += 1;
             while (it.next()) |kv| : (idx += 1) {
                 if (options.whitespace) |ws| try ws.outputIndent(w);
-                try w.print("\"{s}\": {d}", .{
-                    kv.key_ptr.*.sub_file_path,
-                    kv.value_ptr.*,
-                });
+                const builtin = @import("builtin");
+                if (builtin.target.os.tag == .windows) {
+                    try w.print("\"", .{});
+                    for (kv.key_ptr.*.sub_file_path) |c| {
+                        if (c == '\\') {
+                            try w.print("\\", .{});
+                            try w.print("\\", .{});
+                        } else {
+                            try w.print("{c}", .{c});
+                        }
+                    }
+                    try w.print("\"", .{});
+                    try w.print(": {d}", .{
+                        kv.value_ptr.*,
+                    });
+                } else {
+                    try w.print("\"{s}\": {d}", .{
+                        kv.key_ptr.*.sub_file_path,
+                        kv.value_ptr.*,
+                    });
+                }
                 if (idx != self.data.count() - 1) try w.writeByte(',');
                 try w.writeByte('\n');
             }

From 1a4d00d832ea0c23ce053387fdc7b5976828a295 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Wed, 25 May 2022 23:04:43 -0300
Subject: [PATCH 066/137] add: handling some anytype cases

---
 lib/docs/main.js | 45 +++++++++++++++++++++++++++++++++++----------
 1 file changed, 35 insertions(+), 10 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 7c151ad588..4964496b53 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1426,16 +1426,41 @@ var zigAnalysis;
 
                                   if (isVarArgs && i === fnObj.params.length - 1) {
                                       payloadHtml += '...';
-                                  } else if ("refPath" in value) {
-                                      if (opts.wantHtml) {
-                                          payloadHtml += '';
-                                          payloadHtml +=
-                                            ''
-                                              + exprName(value, opts) + '';
-                                          payloadHtml += '';
-                                      } else {
-                                          payloadHtml += exprName(value, opts);
-                                      }
+                                  } 
+                                  else if ("declRef" in value) {
+                                    if (opts.wantHtml) {
+                                      payloadHtml += '';
+                                      payloadHtml +=
+                                        ''
+                                        + exprName(value, opts) + '';
+                                      payloadHtml += '';
+                                    } else {
+                                      payloadHtml += exprName(value, opts);
+                                    }
+
+                                  } 
+                                  else if ("call" in value) {
+                                    if (opts.wantHtml) {
+                                      payloadHtml += '';
+                                      payloadHtml +=
+                                        ''
+                                        + exprName(value, opts) + '';
+                                      payloadHtml += '';
+                                    } else {
+                                      payloadHtml += exprName(value, opts);
+                                    }
+
+                                  } 
+                                  else if ("refPath" in value) {
+                                    if (opts.wantHtml) {
+                                      payloadHtml += '';
+                                      payloadHtml +=
+                                        ''
+                                        + exprName(value, opts) + '';
+                                      payloadHtml += '';
+                                    } else {
+                                      payloadHtml += exprName(value, opts);
+                                    }
 
                                   } else if ("type" in value) {
                                       let name = exprName(value, {

From e1d55385ff3916f2a522225c41a239068972fdf4 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Thu, 26 May 2022 05:26:10 -0300
Subject: [PATCH 067/137] add: typeof_builtin (not fully implemented)

---
 src/Autodoc.zig | 81 ++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 64 insertions(+), 17 deletions(-)

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index db462dea92..9a90d03c2c 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -297,8 +297,7 @@ const DocData = struct {
                     try w.print("\"", .{});
                     for (kv.key_ptr.*.sub_file_path) |c| {
                         if (c == '\\') {
-                            try w.print("\\", .{});
-                            try w.print("\\", .{});
+                            try w.print("\\\\", .{});
                         } else {
                             try w.print("{c}", .{c});
                         }
@@ -1242,6 +1241,42 @@ fn walkInstruction(
                 .expr = .{ .typeOf = operand_index },
             };
         },
+        .typeof_builtin => {
+            // @check: @TypeOf(T)
+            // right now it's only showing the T
+            // a way to solve it could be creating a .call
+            // another way is with a flag to handle it on Frontend
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Block, pl_node.payload_index);
+            const body = file.zir.extra[extra.end..][extra.data.body_len - 1];
+
+            var operand: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                data[body].@"break".operand,
+                false,
+            );
+
+            return operand;
+        },
+        .type_info => {
+            // @check
+            const un_node = data[inst_index].un_node;
+            const operand = try self.walkRef(
+                file,
+                parent_scope,
+                un_node.operand,
+                need_type,
+            );
+
+            const operand_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, operand.expr);
+
+            return DocData.WalkResult{
+                .typeRef = operand.typeRef,
+                .expr = .{ .typeOf = operand_index },
+            };
+        },
         .as_node => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.As, pl_node.payload_index);
@@ -1534,7 +1569,7 @@ fn walkInstruction(
                 .expr = .{ .call = call_slot_index },
             };
         },
-        .func, .func_inferred => {
+        .func, .func_inferred, .func_extended => {
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{ .Unanalyzed = {} });
 
@@ -2558,12 +2593,14 @@ fn analyzeFunction(
     // TODO: handle scope rules for fn parameters
     for (fn_info.param_body[0..fn_info.total_params_len]) |param_index| {
         switch (tags[param_index]) {
-            else => panicWithContext(
-                file,
-                param_index,
-                "TODO: handle `{s}` in walkInstruction.func\n",
-                .{@tagName(tags[param_index])},
-            ),
+            else => {
+                panicWithContext(
+                    file,
+                    param_index,
+                    "TODO: handle `{s}` in walkInstruction.func\n",
+                    .{@tagName(tags[param_index])},
+                );
+            },
             .param_anytype, .param_anytype_comptime => {
                 // TODO: where are the doc comments?
                 const str_tok = data[param_index].str_tok;
@@ -2848,17 +2885,27 @@ fn walkRef(
                 };
             },
             // TODO: dunno what to do with those
+            // .calling_convention_type => {
+            //     return DocData.WalkResult{
+            //         .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+            //         .expr = .{ .int = .{ .value = 1 } },
+            //     };
+            // },
             // .calling_convention_c => {
-            //     return DocData.WalkResult{ .int = .{
-            //         .type = @enumToInt(Ref.comptime_int_type),
-            //         .value = 1,
-            //     } };
+            //     return DocData.WalkResult{
+            //         .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+            //         .expr = .{ .int = .{ .value = 1 } },
+            //     };
             // },
             // .calling_convention_inline => {
-            //     return DocData.WalkResult{ .int = .{
-            //         .type = @enumToInt(Ref.comptime_int_type),
-            //         .value = 1,
-            //     } };
+            //     return DocData.WalkResult{
+            //         .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+            //         .expr = .{ .int = .{ .value = 1 } },
+            //     };
+            //     // return DocData.WalkResult{ .int = .{
+            //     //     .type = @enumToInt(Ref.comptime_int_type),
+            //     //     .value = 1,
+            //     // } };
             // },
             // .generic_poison => {
             //     return DocData.WalkResult{ .int = .{

From 270e2c18bf4dde537361f40819fb8d3991249586 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Thu, 26 May 2022 16:47:16 -0300
Subject: [PATCH 068/137] fix: @TypeOf() now rendering

---
 lib/docs/main.js |  5 +++++
 src/Autodoc.zig  | 12 +++++++-----
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 4964496b53..4f4d68f7b0 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1083,6 +1083,11 @@ var zigAnalysis;
               struct_body += "}";
             return struct_body;
           }
+          case "typeOf": {
+            const typeRefArg = zigAnalysis.exprs[expr.typeOf];
+            let payloadHtml = "@TypeOf(" + exprName(typeRefArg) + ")";
+            return payloadHtml;
+          }
           case "null": {
             return "null";
           }
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 9a90d03c2c..6302abccf2 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -1242,10 +1242,6 @@ fn walkInstruction(
             };
         },
         .typeof_builtin => {
-            // @check: @TypeOf(T)
-            // right now it's only showing the T
-            // a way to solve it could be creating a .call
-            // another way is with a flag to handle it on Frontend
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Block, pl_node.payload_index);
             const body = file.zir.extra[extra.end..][extra.data.body_len - 1];
@@ -1257,7 +1253,13 @@ fn walkInstruction(
                 false,
             );
 
-            return operand;
+            const operand_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, operand.expr);
+
+            return DocData.WalkResult{
+                .typeRef = operand.typeRef,
+                .expr = .{ .typeOf = operand_index },
+            };
         },
         .type_info => {
             // @check

From 17928428082768497d909b3fd55615be21a7660c Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Thu, 26 May 2022 16:57:20 -0300
Subject: [PATCH 069/137] fix: typeOf "match failed" with a call after
 @TypeOf()

---
 src/Autodoc.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 6302abccf2..b98adba2db 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -2376,7 +2376,7 @@ fn tryResolveRefPath(
                 path[i + 1] = (try self.cteTodo("match failure")).expr;
                 continue :outer;
             },
-            .comptimeExpr, .call => {
+            .comptimeExpr, .call, .typeOf => {
                 // Since we hit a cte, we leave the remaining strings unresolved
                 // and completely give up on resolving this decl path.
                 //decl_path.hasCte = true;

From 4bd359a8498e3c239a03abc4f84bb18c0e5617ae Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Thu, 26 May 2022 22:18:55 -0300
Subject: [PATCH 070/137] add: handling typeof_peer

---
 lib/docs/main.js | 42 +++++++++++++++++++++++++++++++++++++++---
 src/Autodoc.zig  | 34 +++++++++++++++++++++++++++++++++-
 2 files changed, 72 insertions(+), 4 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 4f4d68f7b0..4a59d5d2bc 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1083,9 +1083,23 @@ var zigAnalysis;
               struct_body += "}";
             return struct_body;
           }
+          case "typeOf_peer": {
+            console.log(expr)
+            let payloadHtml = "@TypeOf("
+            for (let i = 0; i < expr.typeOf_peer.length; i++) {
+              payloadHtml += exprName(expr.typeOf_peer[i], {wantHtml: true, wantLink:true});
+              if (i !== expr.typeOf_peer.length - 1) {
+                payloadHtml += ", ";
+              }
+            }
+            payloadHtml += ")";
+            console.log(payloadHtml)
+            return payloadHtml;
+
+          }
           case "typeOf": {
             const typeRefArg = zigAnalysis.exprs[expr.typeOf];
-            let payloadHtml = "@TypeOf(" + exprName(typeRefArg) + ")";
+            let payloadHtml = "@TypeOf(" + exprName(typeRefArg, {wantHtml: true, wantLink:true}) + ")";
             return payloadHtml;
           }
           case "null": {
@@ -1432,6 +1446,30 @@ var zigAnalysis;
                                   if (isVarArgs && i === fnObj.params.length - 1) {
                                       payloadHtml += '...';
                                   } 
+                                  else if ("typeOf" in value) {
+                                    if (opts.wantHtml) {
+                                      payloadHtml += '';
+                                      payloadHtml +=
+                                        ''
+                                        + exprName(value, opts) + '';
+                                      payloadHtml += '';
+                                    } else {
+                                      payloadHtml += exprName(value, opts);
+                                    }
+
+                                  } 
+                                  else if ("typeOf_peer" in value) {
+                                    if (opts.wantHtml) {
+                                      payloadHtml += '';
+                                      payloadHtml +=
+                                        ''
+                                        + exprName(value, opts) + '';
+                                      payloadHtml += '';
+                                    } else {
+                                      payloadHtml += exprName(value, opts);
+                                    }
+
+                                  } 
                                   else if ("declRef" in value) {
                                     if (opts.wantHtml) {
                                       payloadHtml += '';
@@ -1454,7 +1492,6 @@ var zigAnalysis;
                                     } else {
                                       payloadHtml += exprName(value, opts);
                                     }
-
                                   } 
                                   else if ("refPath" in value) {
                                     if (opts.wantHtml) {
@@ -1466,7 +1503,6 @@ var zigAnalysis;
                                     } else {
                                       payloadHtml += exprName(value, opts);
                                     }
-
                                   } else if ("type" in value) {
                                       let name = exprName(value, {
                                         wantHtml: false,
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index b98adba2db..655fb5339d 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -575,6 +575,7 @@ const DocData = struct {
         call: usize, // index in `calls`
         enumLiteral: []const u8, // direct value
         typeOf: usize, // index in `exprs`
+        typeOf_peer: []Expr,
         as: As,
         sizeOf: usize, // index in `exprs`
         compileError: []const u8,
@@ -641,6 +642,14 @@ const DocData = struct {
                     options,
                     w,
                 ),
+                .typeOf_peer => |v| {
+                    try w.print("{{ \"typeOf_peer\": [", .{});
+                    for (v) |c, i| {
+                        const comma = if (i == v.len - 1) "]}" else ",\n";
+                        try c.jsonStringify(options, w);
+                        try w.print("{s}", .{comma});
+                    }
+                },
                 .refPath => |v| {
                     try w.print("{{ \"refPath\": [", .{});
                     for (v) |c, i| {
@@ -1509,7 +1518,8 @@ fn walkInstruction(
                 .expr = .{ .type = type_slot_index },
             };
         },
-        .param_anytype => {
+        .param_anytype, .param_anytype_comptime => {
+            // @check if .param_anytype_comptime can be here
             // Analysis of anytype function params happens in `.func`.
             // This switch case handles the case where an expression depends
             // on an anytype field. E.g.: `fn foo(bar: anytype) @TypeOf(bar)`.
@@ -1527,6 +1537,13 @@ fn walkInstruction(
             const pl_tok = data[inst_index].pl_tok;
             const extra = file.zir.extraData(Zir.Inst.Param, pl_tok.payload_index);
             const name = file.zir.nullTerminatedString(extra.data.name);
+
+            std.debug.print("param\n", .{});
+            std.debug.print("pl_tok = {any}\n", .{pl_tok});
+            std.debug.print("extra = {any}\n", .{extra});
+            std.debug.print("name = {any}\n", .{name});
+            std.debug.print("param\n", .{});
+
             const cte_slot_index = self.comptime_exprs.items.len;
             try self.comptime_exprs.append(self.arena, .{
                 .code = name,
@@ -1595,7 +1612,22 @@ fn walkInstruction(
                     );
                     return self.cteTodo(@tagName(extended.opcode));
                 },
+                .typeof_peer => {
+                    // Zir says it's a NodeMultiOp but in this case it's TypeOfPeer
+                    const extra = file.zir.extraData(Zir.Inst.TypeOfPeer, extended.operand);
+                    const args = file.zir.refSlice(extra.end, extended.small);
+                    const operand_index = self.exprs.items.len;
+                    for (args) |arg, idx| {
+                        const wr = try self.walkRef(file, parent_scope, arg, idx == 0);
 
+                        try self.exprs.append(self.arena, wr.expr);
+                    }
+
+                    return DocData.WalkResult{
+                        .typeRef = .{ .type = @enumToInt(Ref.void_type) },
+                        .expr = .{ .typeOf_peer = self.exprs.items[operand_index..] },
+                    };
+                },
                 .opaque_decl => return self.cteTodo("opaque {...}"),
                 .variable => {
                     const small = @bitCast(Zir.Inst.ExtendedVar.Small, extended.small);

From c449788b11d0184b356c6258fad33cc20813fd7d Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Fri, 27 May 2022 00:04:02 -0300
Subject: [PATCH 071/137] fix: typeOf_peer working in all cases

---
 lib/docs/main.js |  3 ++-
 src/Autodoc.zig  | 51 ++++++++++++++++++++++++++++++------------------
 2 files changed, 34 insertions(+), 20 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 4a59d5d2bc..ccc74697b9 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1087,7 +1087,8 @@ var zigAnalysis;
             console.log(expr)
             let payloadHtml = "@TypeOf("
             for (let i = 0; i < expr.typeOf_peer.length; i++) {
-              payloadHtml += exprName(expr.typeOf_peer[i], {wantHtml: true, wantLink:true});
+              let elem = zigAnalysis.exprs[expr.typeOf_peer[i]];
+              payloadHtml += exprName(elem, {wantHtml: true, wantLink:true});
               if (i !== expr.typeOf_peer.length - 1) {
                 payloadHtml += ", ";
               }
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 655fb5339d..db553c584c 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -575,7 +575,7 @@ const DocData = struct {
         call: usize, // index in `calls`
         enumLiteral: []const u8, // direct value
         typeOf: usize, // index in `exprs`
-        typeOf_peer: []Expr,
+        typeOf_peer: []usize,
         as: As,
         sizeOf: usize, // index in `exprs`
         compileError: []const u8,
@@ -642,14 +642,6 @@ const DocData = struct {
                     options,
                     w,
                 ),
-                .typeOf_peer => |v| {
-                    try w.print("{{ \"typeOf_peer\": [", .{});
-                    for (v) |c, i| {
-                        const comma = if (i == v.len - 1) "]}" else ",\n";
-                        try c.jsonStringify(options, w);
-                        try w.print("{s}", .{comma});
-                    }
-                },
                 .refPath => |v| {
                     try w.print("{{ \"refPath\": [", .{});
                     for (v) |c, i| {
@@ -658,6 +650,11 @@ const DocData = struct {
                         try w.print("{s}", .{comma});
                     }
                 },
+                .typeOf_peer => |v| try std.json.stringify(
+                    struct { typeOf_peer: []usize }{ .typeOf_peer = v },
+                    options,
+                    w,
+                ),
                 .array => |v| try std.json.stringify(
                     struct { @"array": []usize }{ .@"array" = v },
                     options,
@@ -1538,12 +1535,6 @@ fn walkInstruction(
             const extra = file.zir.extraData(Zir.Inst.Param, pl_tok.payload_index);
             const name = file.zir.nullTerminatedString(extra.data.name);
 
-            std.debug.print("param\n", .{});
-            std.debug.print("pl_tok = {any}\n", .{pl_tok});
-            std.debug.print("extra = {any}\n", .{extra});
-            std.debug.print("name = {any}\n", .{name});
-            std.debug.print("param\n", .{});
-
             const cte_slot_index = self.comptime_exprs.items.len;
             try self.comptime_exprs.append(self.arena, .{
                 .code = name,
@@ -1616,17 +1607,38 @@ fn walkInstruction(
                     // Zir says it's a NodeMultiOp but in this case it's TypeOfPeer
                     const extra = file.zir.extraData(Zir.Inst.TypeOfPeer, extended.operand);
                     const args = file.zir.refSlice(extra.end, extended.small);
-                    const operand_index = self.exprs.items.len;
+                    const array_data = try self.arena.alloc(usize, args.len);
+
+                    var array_type: ?DocData.Expr = null;
                     for (args) |arg, idx| {
                         const wr = try self.walkRef(file, parent_scope, arg, idx == 0);
+                        if (idx == 0) {
+                            array_type = wr.typeRef;
+                        }
 
+                        const expr_index = self.exprs.items.len;
                         try self.exprs.append(self.arena, wr.expr);
+                        array_data[idx] = expr_index;
                     }
 
-                    return DocData.WalkResult{
-                        .typeRef = .{ .type = @enumToInt(Ref.void_type) },
-                        .expr = .{ .typeOf_peer = self.exprs.items[operand_index..] },
+                    const type_slot_index = self.types.items.len;
+                    try self.types.append(self.arena, .{
+                        .Array = .{
+                            .len = .{
+                                .int = .{
+                                    .value = args.len,
+                                    .negated = false,
+                                },
+                            },
+                            .child = array_type.?,
+                        },
+                    });
+                    const result = DocData.WalkResult{
+                        .typeRef = .{ .type = type_slot_index },
+                        .expr = .{ .typeOf_peer = array_data },
                     };
+
+                    return result;
                 },
                 .opaque_decl => return self.cteTodo("opaque {...}"),
                 .variable => {
@@ -2682,6 +2694,7 @@ fn analyzeFunction(
         const last_instr_index = fn_info.ret_ty_body[fn_info.ret_ty_body.len - 1];
         const break_operand = data[last_instr_index].@"break".operand;
         const wr = try self.walkRef(file, scope, break_operand, false);
+
         break :blk wr;
     };
 

From 76e934dba802fb7f0fdc7ed9f3d8d1561078132a Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Fri, 27 May 2022 03:39:12 -0300
Subject: [PATCH 072/137] fix: comptime not showing in all anytype params
 anymore. add: pointer flags

---
 lib/docs/main.js | 21 ++++++++++------
 src/Autodoc.zig  | 65 ++++++++++++++++++++++++++++++++++++++++--------
 2 files changed, 68 insertions(+), 18 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index ccc74697b9..4bc867d297 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1210,6 +1210,7 @@ var zigAnalysis;
                     let sentinel = ptrObj.sentinel ? ":"+exprName(ptrObj.sentinel, opts) : "";
                       let is_mutable = !ptrObj.is_mutable ? "const " : "";
                       let name = "";
+                    console.log(ptrObj);
                       switch (ptrObj.size) {
                           default:
                               console.log("TODO: implement unhandled pointer size case");
@@ -1236,21 +1237,25 @@ var zigAnalysis;
                               name += is_mutable;
                               break;
                       }
-                      if (ptrObj['const']) {
+                      if (!ptrObj.is_mutable) {
                           if (opts.wantHtml) {
                               name += 'const ';
                           } else {
                               name += "const ";
                           }
                       }
-                      if (ptrObj['volatile']) {
-                          if (opts.wantHtml) {
-                              name += 'volatile ';
-                          } else {
-                              name += "volatile ";
-                          }
+                      if (ptrObj.is_allowzero) {
+                              name += "allowzero ";
                       }
-                      if (ptrObj.align != null) {
+                      if (ptrObj.is_volatile) {
+                              name += "volatile ";
+                      }
+                      if (ptrObj.has_addrspace) {
+                              name += "addrspace(";
+                              name += "." + "";
+                              name += ") ";
+                      }
+                      if (ptrObj.has_align) {
                           if (opts.wantHtml) {
                               name += 'align(';
                           } else {
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index db553c584c..2111147060 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -400,7 +400,13 @@ const DocData = struct {
             size: std.builtin.TypeInfo.Pointer.Size,
             child: Expr,
             sentinel: ?Expr = null,
-            is_mutable: bool = true,
+            is_allowzero: bool = false,
+            is_mutable: bool = false,
+            is_volatile: bool = false,
+            has_sentinel: bool = false,
+            has_align: bool = false,
+            has_addrspace: bool = false,
+            has_bit_range: bool = false,
         },
         Array: struct {
             len: Expr,
@@ -507,9 +513,15 @@ const DocData = struct {
                         try w.print(",", .{});
                     }
                     try w.print(
+                        \\"is_allowzero": {},
                         \\"is_mutable": {},
+                        \\"is_volatile": {},
+                        \\"has_sentinel": {},
+                        \\"has_align": {},
+                        \\"has_addrspace": {},
+                        \\"has_bit_range": {},
                         \\
-                    , .{v.is_mutable});
+                    , .{ v.is_allowzero, v.is_mutable, v.is_volatile, v.has_sentinel, v.has_align, v.has_addrspace, v.has_bit_range });
                     if (options.whitespace) |ws| try ws.outputIndent(w);
                     try w.print(
                         \\"child":
@@ -880,11 +892,7 @@ fn walkInstruction(
             const type_slot_index = self.types.items.len;
             const elem_type_ref = try self.walkRef(file, parent_scope, ptr.elem_type, false);
             try self.types.append(self.arena, .{
-                .Pointer = .{
-                    .size = ptr.size,
-                    .child = elem_type_ref.expr,
-                    .is_mutable = ptr.is_mutable,
-                },
+                .Pointer = .{ .size = ptr.size, .child = elem_type_ref.expr, .is_mutable = ptr.is_mutable, .is_volatile = ptr.is_volatile, .is_allowzero = ptr.is_allowzero },
             });
 
             return DocData.WalkResult{
@@ -904,8 +912,10 @@ fn walkInstruction(
                 false,
             );
 
+            const sentinel: ?DocData.Expr = if (ptr.flags.has_sentinel) DocData.Expr{ .int = .{ .value = 0, .negated = false } } else null;
+
             try self.types.append(self.arena, .{
-                .Pointer = .{ .size = ptr.size, .child = elem_type_ref.expr, .sentinel = .{ .int = .{ .value = 0, .negated = false } }, .is_mutable = ptr.flags.is_mutable },
+                .Pointer = .{ .size = ptr.size, .child = elem_type_ref.expr, .sentinel = sentinel, .is_mutable = ptr.flags.is_mutable, .has_align = ptr.flags.has_align, .has_sentinel = ptr.flags.has_sentinel, .is_volatile = ptr.flags.is_volatile, .has_addrspace = ptr.flags.has_addrspace, .has_bit_range = ptr.flags.has_bit_range },
             });
             return DocData.WalkResult{
                 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
@@ -1194,6 +1204,20 @@ fn walkInstruction(
                 .expr = .{ .float = float },
             };
         },
+        .float128 => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Float128, pl_node.payload_index);
+            _ = pl_node;
+            _ = extra;
+
+            // printWithContext(
+            //     file,
+            //     inst_index,
+            //     "TODO: implement `{s}` for walkInstruction\n\n",
+            //     .{@tagName(tags[inst_index])},
+            // );
+            return self.cteTodo(@tagName(tags[inst_index]));
+        },
         .negate => {
             const un_node = data[inst_index].un_node;
             var operand: DocData.WalkResult = try self.walkRef(
@@ -1481,6 +1505,27 @@ fn walkInstruction(
                 .expr = .{ .@"struct" = field_vals },
             };
         },
+        .struct_init_empty => {
+            const un_node = data[inst_index].un_node;
+            var operand: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                un_node.operand,
+                false,
+            );
+
+            _ = operand;
+
+            // WIP
+
+            printWithContext(
+                file,
+                inst_index,
+                "TODO: implement `{s}` for walkInstruction\n\n",
+                .{@tagName(tags[inst_index])},
+            );
+            return self.cteTodo(@tagName(tags[inst_index]));
+        },
         .error_set_decl => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.ErrorSetDecl, pl_node.payload_index);
@@ -1630,7 +1675,7 @@ fn walkInstruction(
                                     .negated = false,
                                 },
                             },
-                            .child = array_type.?,
+                            .child = .{ .type = 0 },
                         },
                     });
                     const result = DocData.WalkResult{
@@ -2657,7 +2702,7 @@ fn analyzeFunction(
                 self.ast_nodes.appendAssumeCapacity(.{
                     .name = name,
                     .docs = "",
-                    .@"comptime" = true,
+                    .@"comptime" = tags[param_index] == .param_anytype_comptime,
                 });
 
                 param_type_refs.appendAssumeCapacity(

From f04f23a3aaeb0e0b3b17395fdc7ee0742a3f983e Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sat, 28 May 2022 00:34:35 -0300
Subject: [PATCH 073/137] add: extern, callconv and return errors

---
 lib/docs/main.js | 58 +++++++++++++++----------------
 src/Autodoc.zig  | 88 +++++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 105 insertions(+), 41 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 4bc867d297..167642a3f6 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1062,6 +1062,13 @@ var zigAnalysis;
     function exprName(expr, opts) {
         switch (Object.keys(expr)[0]) {
           default: throw "oh no";
+          case "errorUnion": {
+            const errUnionObj = zigAnalysis.types[expr.errorUnion];
+            let lhs = exprName(errUnionObj.lhs, opts);
+            let rhs = exprName(errUnionObj.rhs, opts);
+            return lhs + "!" + rhs;
+
+          }
           case "struct": {
             const struct_name = zigAnalysis.decls[expr.struct[0].val.typeRef.refPath[0].declRef].name;
             let struct_body = "";
@@ -1084,7 +1091,6 @@ var zigAnalysis;
             return struct_body;
           }
           case "typeOf_peer": {
-            console.log(expr)
             let payloadHtml = "@TypeOf("
             for (let i = 0; i < expr.typeOf_peer.length; i++) {
               let elem = zigAnalysis.exprs[expr.typeOf_peer[i]];
@@ -1094,7 +1100,6 @@ var zigAnalysis;
               }
             }
             payloadHtml += ")";
-            console.log(payloadHtml)
             return payloadHtml;
 
           }
@@ -1111,7 +1116,7 @@ var zigAnalysis;
             for (let i = 0; i < expr.array.length; i++) {
                 if (i != 0) payloadHtml += ", ";
                 let elem = zigAnalysis.exprs[expr.array[i]];
-                payloadHtml += exprName(elem);
+                payloadHtml += exprName(elem, opts);
             }
             return payloadHtml + "}";
           }
@@ -1127,7 +1132,7 @@ var zigAnalysis;
                 default: throw "TODO";
                 case "declRef":
                 case "refPath": {
-                    payloadHtml += exprName(call.func);
+                    payloadHtml += exprName(call.func, opts);
                     break;
                 }
               }
@@ -1135,7 +1140,7 @@ var zigAnalysis;
 
               for (let i = 0; i < call.args.length; i++) {
                   if (i != 0) payloadHtml += ", ";
-                  payloadHtml += exprName(call.args[i]);
+                  payloadHtml += exprName(call.args[i], opts);
               }
 
               payloadHtml += ")";
@@ -1173,7 +1178,6 @@ var zigAnalysis;
 
               let typeObj = expr.type;
               if (typeof typeObj === 'number') typeObj = zigAnalysis.types[typeObj];
-
               switch (typeObj.kind) {
                   default: throw "TODO";
                   case typeKinds.ComptimeExpr:
@@ -1210,7 +1214,6 @@ var zigAnalysis;
                     let sentinel = ptrObj.sentinel ? ":"+exprName(ptrObj.sentinel, opts) : "";
                       let is_mutable = !ptrObj.is_mutable ? "const " : "";
                       let name = "";
-                    console.log(ptrObj);
                       switch (ptrObj.size) {
                           default:
                               console.log("TODO: implement unhandled pointer size case");
@@ -1352,40 +1355,29 @@ var zigAnalysis;
                   {
                       let errSetObj = /** @type {ErrSetType} */(typeObj);
                       if (errSetObj.fields == null) {
-                          if (wantHtml) {
                               return 'anyerror';
-                          } else {
-                              return "anyerror";
-                          }
                       } else {
-                          throw "TODO";
-                          // if (wantHtml) {
-                          //     return escapeHtml(typeObj.name);
-                          // } else {
-                          //     return typeObj.name;
-                          // }
+                          // throw "TODO";
+                        let html = "error{" + errSetObj.fields[0].name + "}";
+                        return html;
                       }
                   }
+                  
                   case typeKinds.ErrorUnion:
                   {
-                      throw "TODO";
-                      // TODO: implement error union printing assuming that both
-                      // payload and error union are walk results!
-                      // let errUnionObj = /** @type {ErrUnionType} */(typeObj);
-                      // let errSetTypeObj = /** @type {ErrSetType} */ (zigAnalysis.types[errUnionObj.err]);
-                      // let payloadHtml = typeValueName(errUnionObj.payload, wantHtml, wantSubLink, null);
-                      // if (fnDecl != null && errSetTypeObj.fn === fnDecl.value.type) {
-                      //     // function index parameter supplied and this is the inferred error set of it
-                      //     return "!" + payloadHtml;
-                      // } else {
-                      //     return typeValueName(errUnionObj.err, wantHtml, wantSubLink, null) + "!" + payloadHtml;
-                      // }
+                    let errUnionObj = /** @type {ErrUnionType} */(typeObj);
+                    let lhs = exprName(errUnionObj.lhs, opts);
+                    let rhs = exprName(errUnionObj.rhs, opts);
+                    return lhs + "!" + rhs;
                   }
                   case typeKinds.Fn:
                   {
                       let fnObj = /** @type {Fn} */(typeObj);
                       let payloadHtml = "";
                       if (opts.wantHtml) {
+                          if (fnObj.is_extern) {
+                            payloadHtml += "pub \"extern\" ";
+                          }
                           payloadHtml += 'fn';
                           if (opts.fnDecl) {
                               payloadHtml += ' ';
@@ -1533,6 +1525,14 @@ var zigAnalysis;
                           }
 
                       payloadHtml += ') ';
+                    if (fnObj.has_cc) {
+                      let cc = zigAnalysis.types[fnObj.cc]
+                      payloadHtml += "callconv(." + cc.name + ") ";
+                    }
+
+                      if (fnObj.is_inferred_error) {
+                          payloadHtml += "!";
+                      }
                       if (fnObj.ret != null) {
                           payloadHtml += exprName(fnObj.ret, opts);
                       } else if (opts.wantHtml) {
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 2111147060..380aab41c9 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -153,6 +153,9 @@ pub fn generateZirData(self: *Autodoc) !void {
                     .type_type => .{
                         .Type = .{ .name = tmpbuf.toOwnedSlice() },
                     },
+                    .anyerror_type => .{
+                        .ErrorSet = .{ .name = tmpbuf.toOwnedSlice() },
+                    },
                 },
             );
         }
@@ -429,10 +432,11 @@ const DocData = struct {
             name: []const u8,
             child: Expr,
         },
-        ErrorUnion: struct { name: []const u8 },
+        ErrorUnion: struct { lhs: Expr, rhs: Expr },
+        // ErrorUnion: struct { name: []const u8 },
         ErrorSet: struct {
             name: []const u8,
-            fields: []const Field,
+            fields: ?[]const Field = null,
             // TODO: fn field for inferred error sets?
         },
         Enum: struct {
@@ -454,6 +458,14 @@ const DocData = struct {
             src: ?usize = null, // index into astNodes
             ret: Expr,
             params: ?[]Expr = null, // (use src->fields to find names)
+            is_var_args: bool = false,
+            is_inferred_error: bool = false,
+            has_lib_name: bool = false,
+            has_cc: bool = false,
+            cc: ?usize = null,
+            has_align: bool = false,
+            is_test: bool = false,
+            is_extern: bool = false,
         },
         BoundFn: struct { name: []const u8 },
         Opaque: struct { name: []const u8 },
@@ -492,6 +504,7 @@ const DocData = struct {
                 .Fn => |v| try printTypeBody(v, options, w),
                 .Union => |v| try printTypeBody(v, options, w),
                 .ErrorSet => |v| try printTypeBody(v, options, w),
+                .ErrorUnion => |v| try printTypeBody(v, options, w),
                 .Enum => |v| try printTypeBody(v, options, w),
                 .Int => |v| try printTypeBody(v, options, w),
                 .Float => |v| try printTypeBody(v, options, w),
@@ -588,6 +601,7 @@ const DocData = struct {
         enumLiteral: []const u8, // direct value
         typeOf: usize, // index in `exprs`
         typeOf_peer: []usize,
+        errorUnion: usize, // index in `exprs`
         as: As,
         sizeOf: usize, // index in `exprs`
         compileError: []const u8,
@@ -617,7 +631,7 @@ const DocData = struct {
                         \\{{ "{s}":{{}} }}
                     , .{@tagName(self)});
                 },
-                .type, .comptimeExpr, .call, .this, .declRef, .typeOf => |v| {
+                .type, .comptimeExpr, .call, .this, .declRef, .typeOf, .errorUnion => |v| {
                     try w.print(
                         \\{{ "{s}":{} }}
                     , .{ @tagName(self), v });
@@ -853,7 +867,7 @@ fn walkInstruction(
             const literal = file.zir.nullTerminatedString(str_tok.start);
             const type_index = self.types.items.len;
             try self.types.append(self.arena, .{
-                .EnumLiteral = .{ .name = "todo enum literal" },
+                .EnumLiteral = .{ .name = literal },
             });
 
             return DocData.WalkResult{
@@ -872,8 +886,29 @@ fn walkInstruction(
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
 
-            // TODO: return the actual error union instread of cheating
-            return self.walkRef(file, parent_scope, extra.data.rhs, need_type);
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const type_slot_index = self.types.items.len;
+            try self.types.append(self.arena, .{ .ErrorUnion = .{
+                .lhs = lhs.expr,
+                .rhs = rhs.expr,
+            } });
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .errorUnion = type_slot_index },
+            };
         },
         .elem_type => {
             const un_node = data[inst_index].un_node;
@@ -2744,14 +2779,43 @@ fn analyzeFunction(
     };
 
     self.ast_nodes.items[self_ast_node_index].fields = param_ast_indexes.items;
-    self.types.items[type_slot_index] = .{
-        .Fn = .{
-            .name = "todo_name func",
-            .src = self_ast_node_index,
-            .params = param_type_refs.items,
-            .ret = ret_type_ref.expr,
+    self.types.items[type_slot_index] = switch (tags[inst_index]) {
+        .func, .func_inferred => blk: {
+            break :blk .{
+                .Fn = .{
+                    .name = "todo_name func",
+                    .src = self_ast_node_index,
+                    .params = param_type_refs.items,
+                    .ret = ret_type_ref.expr,
+                },
+            };
         },
+        .func_extended => blk: {
+            const inst_data = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.ExtendedFunc, inst_data.payload_index);
+
+            var cc_index: ?usize = null;
+            if (extra.data.bits.has_cc) {
+                const cc_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra.end]);
+                _ = try self.walkRef(file, scope, cc_ref, false);
+                cc_index = self.types.items.len - 1;
+            }
+            break :blk .{
+                .Fn = .{
+                    .name = "todo_name func",
+                    .src = self_ast_node_index,
+                    .params = param_type_refs.items,
+                    .ret = ret_type_ref.expr,
+                    .is_extern = extra.data.bits.is_extern,
+                    .has_cc = extra.data.bits.has_cc,
+                    .is_inferred_error = extra.data.bits.is_inferred_error,
+                    .cc = cc_index,
+                },
+            };
+        },
+        else => unreachable,
     };
+
     return DocData.WalkResult{
         .typeRef = .{ .type = @enumToInt(Ref.type_type) },
         .expr = .{ .type = type_slot_index },

From 11eb11d7d6b54ac56aa9a5560f21140220bbe487 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sat, 28 May 2022 06:37:25 -0300
Subject: [PATCH 074/137] fix: slices

---
 lib/docs/main.js | 19 +++++-----
 src/Autodoc.zig  | 92 ++++++++++++++----------------------------------
 2 files changed, 37 insertions(+), 74 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 167642a3f6..40d2598f11 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1193,7 +1193,7 @@ var zigAnalysis;
                     let name = "[";
                     let lenName = exprName(arrayObj.len, opts);
                     let sentinel = arrayObj.sentinel ? ":"+exprName(arrayObj.sentinel, opts) : "";
-                    let is_mutable = arrayObj.is_multable ? "const " : "";
+                    // let is_mutable = arrayObj.is_multable ? "const " : "";
 
                     if (opts.wantHtml) {
                       name +=
@@ -1202,7 +1202,7 @@ var zigAnalysis;
                       name += lenName + sentinel;
                     }
                     name += "]";
-                    name += is_mutable;
+                    // name += is_mutable;
                     name += exprName(arrayObj.child, opts);
                     return name;
                   }
@@ -1240,13 +1240,14 @@ var zigAnalysis;
                               name += is_mutable;
                               break;
                       }
-                      if (!ptrObj.is_mutable) {
-                          if (opts.wantHtml) {
-                              name += 'const ';
-                          } else {
-                              name += "const ";
-                          }
-                      }
+                      // @check: after the major changes in arrays the consts are came from switch above
+                      // if (!ptrObj.is_mutable) {
+                      //     if (opts.wantHtml) {
+                      //         name += 'const ';
+                      //     } else {
+                      //         name += "const ";
+                      //     }
+                      // }
                       if (ptrObj.is_allowzero) {
                               name += "allowzero ";
                       }
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 380aab41c9..27fc426379 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -536,9 +536,9 @@ const DocData = struct {
                         \\
                     , .{ v.is_allowzero, v.is_mutable, v.is_volatile, v.has_sentinel, v.has_align, v.has_addrspace, v.has_bit_range });
                     if (options.whitespace) |ws| try ws.outputIndent(w);
-                    try w.print(
-                        \\"child":
-                    , .{});
+                    // try w.print(
+                    //     \\"child":
+                    // , .{});
 
                     if (options.whitespace) |*ws| ws.indent_level += 1;
                     try v.child.jsonStringify(options, w);
@@ -924,8 +924,8 @@ fn walkInstruction(
         },
         .ptr_type_simple => {
             const ptr = data[inst_index].ptr_type_simple;
-            const type_slot_index = self.types.items.len;
             const elem_type_ref = try self.walkRef(file, parent_scope, ptr.elem_type, false);
+            const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
                 .Pointer = .{ .size = ptr.size, .child = elem_type_ref.expr, .is_mutable = ptr.is_mutable, .is_volatile = ptr.is_volatile, .is_allowzero = ptr.is_allowzero },
             });
@@ -948,7 +948,6 @@ fn walkInstruction(
             );
 
             const sentinel: ?DocData.Expr = if (ptr.flags.has_sentinel) DocData.Expr{ .int = .{ .value = 0, .negated = false } } else null;
-
             try self.types.append(self.arena, .{
                 .Pointer = .{ .size = ptr.size, .child = elem_type_ref.expr, .sentinel = sentinel, .is_mutable = ptr.flags.is_mutable, .has_align = ptr.flags.has_align, .has_sentinel = ptr.flags.has_sentinel, .is_volatile = ptr.flags.is_volatile, .has_addrspace = ptr.flags.has_addrspace, .has_bit_range = ptr.flags.has_bit_range },
             });
@@ -1021,14 +1020,11 @@ fn walkInstruction(
             }
 
             const type_slot_index = self.types.items.len;
-            try self.types.append(self.arena, .{
-                .Array = .{ .len = .{
-                    .int = .{
-                        .value = operands.len,
-                        .negated = false,
-                    },
-                }, .child = array_type.? },
-            });
+            try self.types.append(self.arena, .{ .Pointer = .{
+                .size = .Slice,
+                .child = array_type.?,
+                .is_mutable = true,
+            } });
 
             return DocData.WalkResult{
                 .typeRef = .{ .type = type_slot_index },
@@ -1061,14 +1057,7 @@ fn walkInstruction(
             }
 
             const type_slot_index = self.types.items.len;
-            try self.types.append(self.arena, .{
-                .Array = .{ .len = .{
-                    .int = .{
-                        .value = operands.len - 1,
-                        .negated = false,
-                    },
-                }, .child = array_type.?, .sentinel = sentinel },
-            });
+            try self.types.append(self.arena, .{ .Pointer = .{ .size = .Slice, .child = array_type.?, .is_mutable = true, .sentinel = sentinel } });
 
             return DocData.WalkResult{
                 .typeRef = .{ .type = type_slot_index },
@@ -1180,14 +1169,7 @@ fn walkInstruction(
             }
 
             const type_slot_index = self.types.items.len;
-            try self.types.append(self.arena, .{
-                .Array = .{ .len = .{
-                    .int = .{
-                        .value = operands.len - 1,
-                        .negated = false,
-                    },
-                }, .child = array_type.?, .sentinel = sentinel },
-            });
+            try self.types.append(self.arena, .{ .Pointer = .{ .size = .Slice, .child = array_type.?, .is_mutable = true, .sentinel = sentinel } });
 
             return DocData.WalkResult{
                 .typeRef = .{ .type = type_slot_index },
@@ -1198,9 +1180,7 @@ fn walkInstruction(
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.MultiOp, pl_node.payload_index);
             const operands = file.zir.refSlice(extra.end, extra.data.operands_len);
-            const array_data = try self.arena.alloc(usize, operands.len - 1);
-
-            var sentinel: ?DocData.Expr = null;
+            const array_data = try self.arena.alloc(usize, operands.len);
 
             var array_type: ?DocData.Expr = null;
             for (operands) |op, idx| {
@@ -1209,22 +1189,22 @@ fn walkInstruction(
                     array_type = wr.typeRef;
                 }
 
-                if (idx == extra.data.operands_len - 1) {
-                    sentinel = wr.expr;
-                    const expr_index = self.exprs.items.len;
-                    try self.exprs.append(self.arena, wr.expr);
-                    array_data[idx] = expr_index;
-                }
+                const expr_index = self.exprs.items.len;
+                try self.exprs.append(self.arena, wr.expr);
+                array_data[idx] = expr_index;
             }
 
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
-                .Array = .{ .len = .{
-                    .int = .{
-                        .value = operands.len - 1,
-                        .negated = false,
+                .Array = .{
+                    .len = .{
+                        .int = .{
+                            .value = operands.len - 1,
+                            .negated = false,
+                        },
                     },
-                }, .child = array_type.?, .sentinel = sentinel },
+                    .child = array_type.?,
+                },
             });
 
             return DocData.WalkResult{
@@ -1239,20 +1219,6 @@ fn walkInstruction(
                 .expr = .{ .float = float },
             };
         },
-        .float128 => {
-            const pl_node = data[inst_index].pl_node;
-            const extra = file.zir.extraData(Zir.Inst.Float128, pl_node.payload_index);
-            _ = pl_node;
-            _ = extra;
-
-            // printWithContext(
-            //     file,
-            //     inst_index,
-            //     "TODO: implement `{s}` for walkInstruction\n\n",
-            //     .{@tagName(tags[inst_index])},
-            // );
-            return self.cteTodo(@tagName(tags[inst_index]));
-        },
         .negate => {
             const un_node = data[inst_index].un_node;
             var operand: DocData.WalkResult = try self.walkRef(
@@ -2793,13 +2759,13 @@ fn analyzeFunction(
         .func_extended => blk: {
             const inst_data = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.ExtendedFunc, inst_data.payload_index);
-
             var cc_index: ?usize = null;
             if (extra.data.bits.has_cc) {
                 const cc_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra.end]);
                 _ = try self.walkRef(file, scope, cc_ref, false);
                 cc_index = self.types.items.len - 1;
             }
+
             break :blk .{
                 .Fn = .{
                     .name = "todo_name func",
@@ -3043,25 +3009,21 @@ fn walkRef(
             // TODO: dunno what to do with those
             // .calling_convention_type => {
             //     return DocData.WalkResult{
-            //         .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+            //         .typeRef = .{ .type = @enumToInt(Ref.calling_convention_type) },
             //         .expr = .{ .int = .{ .value = 1 } },
             //     };
             // },
             // .calling_convention_c => {
             //     return DocData.WalkResult{
-            //         .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+            //         .typeRef = .{ .type = @enumToInt(Ref.calling_convention_c) },
             //         .expr = .{ .int = .{ .value = 1 } },
             //     };
             // },
             // .calling_convention_inline => {
             //     return DocData.WalkResult{
-            //         .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+            //         .typeRef = .{ .type = @enumToInt(Ref.calling_convention_inline) },
             //         .expr = .{ .int = .{ .value = 1 } },
             //     };
-            //     // return DocData.WalkResult{ .int = .{
-            //     //     .type = @enumToInt(Ref.comptime_int_type),
-            //     //     .value = 1,
-            //     // } };
             // },
             // .generic_poison => {
             //     return DocData.WalkResult{ .int = .{

From a3f44b0d21fd504cd306615f1bdf2294ddc28769 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sat, 28 May 2022 07:22:25 -0300
Subject: [PATCH 075/137] fixes: @check

---
 src/Autodoc.zig | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 27fc426379..57f976ecfd 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -536,9 +536,9 @@ const DocData = struct {
                         \\
                     , .{ v.is_allowzero, v.is_mutable, v.is_volatile, v.has_sentinel, v.has_align, v.has_addrspace, v.has_bit_range });
                     if (options.whitespace) |ws| try ws.outputIndent(w);
-                    // try w.print(
-                    //     \\"child":
-                    // , .{});
+                    try w.print(
+                        \\"child":
+                    , .{});
 
                     if (options.whitespace) |*ws| ws.indent_level += 1;
                     try v.child.jsonStringify(options, w);
@@ -2761,9 +2761,10 @@ fn analyzeFunction(
             const extra = file.zir.extraData(Zir.Inst.ExtendedFunc, inst_data.payload_index);
             var cc_index: ?usize = null;
             if (extra.data.bits.has_cc) {
-                const cc_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra.end]);
-                _ = try self.walkRef(file, scope, cc_ref, false);
-                cc_index = self.types.items.len - 1;
+                // @panic with .calling_convention_inline
+                // const cc_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra.end]);
+                // _ = try self.walkRef(file, scope, cc_ref, false);
+                // cc_index = self.types.items.len - 1;
             }
 
             break :blk .{
@@ -2773,7 +2774,7 @@ fn analyzeFunction(
                     .params = param_type_refs.items,
                     .ret = ret_type_ref.expr,
                     .is_extern = extra.data.bits.is_extern,
-                    .has_cc = extra.data.bits.has_cc,
+                    // .has_cc = extra.data.bits.has_cc,
                     .is_inferred_error = extra.data.bits.is_inferred_error,
                     .cc = cc_index,
                 },

From 2809b01b2f3fcecc4eeec7c1ee44f65ea0b80abb Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sat, 28 May 2022 14:22:46 -0300
Subject: [PATCH 076/137] add: noreturn keyword at end of the fn decl

---
 src/Autodoc.zig | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 57f976ecfd..0209d1bf76 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -147,6 +147,9 @@ pub fn generateZirData(self: *Autodoc) !void {
                         .Bool = .{ .name = tmpbuf.toOwnedSlice() },
                     },
 
+                    .noreturn_type => .{
+                        .NoReturn = .{ .name = tmpbuf.toOwnedSlice() },
+                    },
                     .void_type => .{
                         .Void = .{ .name = tmpbuf.toOwnedSlice() },
                     },
@@ -525,6 +528,7 @@ const DocData = struct {
                         try sentinel.jsonStringify(options, w);
                         try w.print(",", .{});
                     }
+                    if (options.whitespace) |ws| try ws.outputIndent(w);
                     try w.print(
                         \\"is_allowzero": {},
                         \\"is_mutable": {},

From ec8d29ff257a2285665e0559aa53a8cfcb251756 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sat, 28 May 2022 14:30:27 -0300
Subject: [PATCH 077/137] fix: anyopaque_type. it was showing *[1]anyopaque now
 *anyopaque

---
 lib/docs/main.js | 3 ---
 src/Autodoc.zig  | 3 +++
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 40d2598f11..54ce7859c7 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1182,9 +1182,6 @@ var zigAnalysis;
                   default: throw "TODO";
                   case typeKinds.ComptimeExpr:
                   {
-                      // trying to match the std lib types
-                      // the *[1]anyopaque behavior it's happening
-                      // because of the known issue with arrays and pointers
                       return "anyopaque";
                   }
                   case typeKinds.Array:
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 0209d1bf76..5912e4ad70 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -143,6 +143,9 @@ pub fn generateZirData(self: *Autodoc) !void {
                         .ComptimeFloat = .{ .name = tmpbuf.toOwnedSlice() },
                     },
 
+                    .anyopaque_type => .{
+                        .ComptimeExpr = .{ .name = tmpbuf.toOwnedSlice() },
+                    },
                     .bool_type => .{
                         .Bool = .{ .name = tmpbuf.toOwnedSlice() },
                     },

From 0e5a2bbd63d8acb8c570a384db875bc0f25a4999 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sat, 28 May 2022 16:14:40 -0300
Subject: [PATCH 078/137] fix: NoReturn and WIP in calling_conventions

---
 lib/docs/main.js |  4 +++
 src/Autodoc.zig  | 68 ++++++++++++++++++++++++++++++------------------
 2 files changed, 47 insertions(+), 25 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 54ce7859c7..0bbca2b36f 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1180,6 +1180,10 @@ var zigAnalysis;
               if (typeof typeObj === 'number') typeObj = zigAnalysis.types[typeObj];
               switch (typeObj.kind) {
                   default: throw "TODO";
+                  case typeKinds.Unanalyzed:
+                  {
+                      return "Unanalyzed";
+                  }
                   case typeKinds.ComptimeExpr:
                   {
                       return "anyopaque";
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 5912e4ad70..75641374f0 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -162,6 +162,9 @@ pub fn generateZirData(self: *Autodoc) !void {
                     .anyerror_type => .{
                         .ErrorSet = .{ .name = tmpbuf.toOwnedSlice() },
                     },
+                    // .calling_convention_inline, .calling_convention_c, .calling_convention_type => .{
+                    //     .EnumLiteral = .{ .name = tmpbuf.toOwnedSlice() },
+                    // },
                 },
             );
         }
@@ -515,7 +518,15 @@ const DocData = struct {
                 .Int => |v| try printTypeBody(v, options, w),
                 .Float => |v| try printTypeBody(v, options, w),
                 .Type => |v| try printTypeBody(v, options, w),
+                .NoReturn => |v| try printTypeBody(v, options, w),
                 .EnumLiteral => |v| try printTypeBody(v, options, w),
+                .Unanalyzed => |_| {
+                    if (options.whitespace) |ws| try ws.outputIndent(w);
+                    try w.print(
+                        \\"Unanalyzed": "Unanalyzed"
+                        \\
+                    , .{});
+                },
                 .Pointer => |v| {
                     if (options.whitespace) |ws| try ws.outputIndent(w);
                     try w.print(
@@ -2767,12 +2778,16 @@ fn analyzeFunction(
             const inst_data = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.ExtendedFunc, inst_data.payload_index);
             var cc_index: ?usize = null;
-            if (extra.data.bits.has_cc) {
-                // @panic with .calling_convention_inline
-                // const cc_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra.end]);
-                // _ = try self.walkRef(file, scope, cc_ref, false);
-                // cc_index = self.types.items.len - 1;
-            }
+            cc_index = self.types.items.len - 1;
+            // if (extra.data.bits.has_cc) {
+            //     const cc = file.zir.extra[extra.end];
+            //     const cc_ref = @intToEnum(Zir.Inst.Ref, cc);
+            //     _ = try self.walkRef(file, scope, cc_ref, false);
+            //     cc_index = self.types.items.len - 1;
+            //     std.debug.print("DONE\n", .{});
+            //     std.debug.print("cc_ref = {any}\n", .{cc_ref});
+            //     std.debug.print("index = {}\n", .{cc_index});
+            // }
 
             break :blk .{
                 .Fn = .{
@@ -2781,7 +2796,7 @@ fn analyzeFunction(
                     .params = param_type_refs.items,
                     .ret = ret_type_ref.expr,
                     .is_extern = extra.data.bits.is_extern,
-                    // .has_cc = extra.data.bits.has_cc,
+                    .has_cc = extra.data.bits.has_cc,
                     .is_inferred_error = extra.data.bits.is_inferred_error,
                     .cc = cc_index,
                 },
@@ -3015,24 +3030,27 @@ fn walkRef(
                 };
             },
             // TODO: dunno what to do with those
-            // .calling_convention_type => {
-            //     return DocData.WalkResult{
-            //         .typeRef = .{ .type = @enumToInt(Ref.calling_convention_type) },
-            //         .expr = .{ .int = .{ .value = 1 } },
-            //     };
-            // },
-            // .calling_convention_c => {
-            //     return DocData.WalkResult{
-            //         .typeRef = .{ .type = @enumToInt(Ref.calling_convention_c) },
-            //         .expr = .{ .int = .{ .value = 1 } },
-            //     };
-            // },
-            // .calling_convention_inline => {
-            //     return DocData.WalkResult{
-            //         .typeRef = .{ .type = @enumToInt(Ref.calling_convention_inline) },
-            //         .expr = .{ .int = .{ .value = 1 } },
-            //     };
-            // },
+            .calling_convention_type => {
+                return DocData.WalkResult{
+                    // .typeRef = .{ .type = @enumToInt(Ref.calling_convention_type) },
+                    .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+                    .expr = .{ .int = .{ .value = 1 } },
+                };
+            },
+            .calling_convention_c => {
+                return DocData.WalkResult{
+                    // .typeRef = .{ .type = @enumToInt(Ref.calling_convention_c) },
+                    .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+                    .expr = .{ .int = .{ .value = 1 } },
+                };
+            },
+            .calling_convention_inline => {
+                return DocData.WalkResult{
+                    // .typeRef = .{ .type = @enumToInt(Ref.calling_convention_inline) },
+                    .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+                    .expr = .{ .int = .{ .value = 1 } },
+                };
+            },
             // .generic_poison => {
             //     return DocData.WalkResult{ .int = .{
             //         .type = @enumToInt(Ref.comptime_int_type),

From 927f087a406602dfca4f56b71cec378ffbfa2949 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sat, 28 May 2022 18:28:21 -0300
Subject: [PATCH 079/137] fix: calling convention

---
 lib/docs/main.js |   8 +-
 src/Autodoc.zig  | 204 +++++++++++++++++++++++++++++++++--------------
 2 files changed, 148 insertions(+), 64 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 0bbca2b36f..22f9b36382 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1180,10 +1180,6 @@ var zigAnalysis;
               if (typeof typeObj === 'number') typeObj = zigAnalysis.types[typeObj];
               switch (typeObj.kind) {
                   default: throw "TODO";
-                  case typeKinds.Unanalyzed:
-                  {
-                      return "Unanalyzed";
-                  }
                   case typeKinds.ComptimeExpr:
                   {
                       return "anyopaque";
@@ -1528,8 +1524,8 @@ var zigAnalysis;
 
                       payloadHtml += ') ';
                     if (fnObj.has_cc) {
-                      let cc = zigAnalysis.types[fnObj.cc]
-                      payloadHtml += "callconv(." + cc.name + ") ";
+                      let cc = zigAnalysis.exprs[fnObj.cc]
+                      payloadHtml += "callconv(." + cc.enumLiteral + ") ";
                     }
 
                       if (fnObj.is_inferred_error) {
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 75641374f0..a278b53209 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -162,9 +162,9 @@ pub fn generateZirData(self: *Autodoc) !void {
                     .anyerror_type => .{
                         .ErrorSet = .{ .name = tmpbuf.toOwnedSlice() },
                     },
-                    // .calling_convention_inline, .calling_convention_c, .calling_convention_type => .{
-                    //     .EnumLiteral = .{ .name = tmpbuf.toOwnedSlice() },
-                    // },
+                    .calling_convention_inline, .calling_convention_c, .calling_convention_type => .{
+                        .EnumLiteral = .{ .name = tmpbuf.toOwnedSlice() },
+                    },
                 },
             );
         }
@@ -520,13 +520,6 @@ const DocData = struct {
                 .Type => |v| try printTypeBody(v, options, w),
                 .NoReturn => |v| try printTypeBody(v, options, w),
                 .EnumLiteral => |v| try printTypeBody(v, options, w),
-                .Unanalyzed => |_| {
-                    if (options.whitespace) |ws| try ws.outputIndent(w);
-                    try w.print(
-                        \\"Unanalyzed": "Unanalyzed"
-                        \\
-                    , .{});
-                },
                 .Pointer => |v| {
                     if (options.whitespace) |ws| try ws.outputIndent(w);
                     try w.print(
@@ -885,7 +878,7 @@ fn walkInstruction(
             const literal = file.zir.nullTerminatedString(str_tok.start);
             const type_index = self.types.items.len;
             try self.types.append(self.arena, .{
-                .EnumLiteral = .{ .name = literal },
+                .EnumLiteral = .{ .name = "todo enum literal" },
             });
 
             return DocData.WalkResult{
@@ -1643,17 +1636,33 @@ fn walkInstruction(
                 .expr = .{ .call = call_slot_index },
             };
         },
-        .func, .func_inferred, .func_extended => {
+        .func, .func_inferred => {
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{ .Unanalyzed = {} });
 
-            return self.analyzeFunction(
+            const result = self.analyzeFunction(
                 file,
                 parent_scope,
                 inst_index,
                 self_ast_node_index,
                 type_slot_index,
             );
+
+            return result;
+        },
+        .func_extended => {
+            const type_slot_index = self.types.items.len;
+            try self.types.append(self.arena, .{ .Unanalyzed = {} });
+
+            const result = self.analyzeFunctionExtended(
+                file,
+                parent_scope,
+                inst_index,
+                self_ast_node_index,
+                type_slot_index,
+            );
+
+            return result;
         },
         .extended => {
             const extended = data[inst_index].extended;
@@ -2677,7 +2686,119 @@ fn tryResolveRefPath(
         //       that said, we might want to store it elsewhere and reclaim memory asap
     }
 }
+fn analyzeFunctionExtended(
+    self: *Autodoc,
+    file: *File,
+    scope: *Scope,
+    inst_index: usize,
+    self_ast_node_index: usize,
+    type_slot_index: usize,
+) error{OutOfMemory}!DocData.WalkResult {
+    const tags = file.zir.instructions.items(.tag);
+    const data = file.zir.instructions.items(.data);
+    const fn_info = file.zir.getFnInfo(@intCast(u32, inst_index));
 
+    try self.ast_nodes.ensureUnusedCapacity(self.arena, fn_info.total_params_len);
+    var param_type_refs = try std.ArrayListUnmanaged(DocData.Expr).initCapacity(
+        self.arena,
+        fn_info.total_params_len,
+    );
+    var param_ast_indexes = try std.ArrayListUnmanaged(usize).initCapacity(
+        self.arena,
+        fn_info.total_params_len,
+    );
+
+    // TODO: handle scope rules for fn parameters
+    for (fn_info.param_body[0..fn_info.total_params_len]) |param_index| {
+        switch (tags[param_index]) {
+            else => {
+                panicWithContext(
+                    file,
+                    param_index,
+                    "TODO: handle `{s}` in walkInstruction.func\n",
+                    .{@tagName(tags[param_index])},
+                );
+            },
+            .param_anytype, .param_anytype_comptime => {
+                // TODO: where are the doc comments?
+                const str_tok = data[param_index].str_tok;
+
+                const name = str_tok.get(file.zir);
+
+                param_ast_indexes.appendAssumeCapacity(self.ast_nodes.items.len);
+                self.ast_nodes.appendAssumeCapacity(.{
+                    .name = name,
+                    .docs = "",
+                    .@"comptime" = tags[param_index] == .param_anytype_comptime,
+                });
+
+                param_type_refs.appendAssumeCapacity(
+                    DocData.Expr{ .@"anytype" = {} },
+                );
+            },
+            .param, .param_comptime => {
+                const pl_tok = data[param_index].pl_tok;
+                const extra = file.zir.extraData(Zir.Inst.Param, pl_tok.payload_index);
+                const doc_comment = if (extra.data.doc_comment != 0)
+                    file.zir.nullTerminatedString(extra.data.doc_comment)
+                else
+                    "";
+                const name = file.zir.nullTerminatedString(extra.data.name);
+
+                param_ast_indexes.appendAssumeCapacity(self.ast_nodes.items.len);
+                try self.ast_nodes.append(self.arena, .{
+                    .name = name,
+                    .docs = doc_comment,
+                    .@"comptime" = tags[param_index] == .param_comptime,
+                });
+
+                const break_index = file.zir.extra[extra.end..][extra.data.body_len - 1];
+                const break_operand = data[break_index].@"break".operand;
+                const param_type_ref = try self.walkRef(file, scope, break_operand, false);
+
+                param_type_refs.appendAssumeCapacity(param_type_ref.expr);
+            },
+        }
+    }
+
+    // ret
+    const ret_type_ref = blk: {
+        const last_instr_index = fn_info.ret_ty_body[fn_info.ret_ty_body.len - 1];
+        const break_operand = data[last_instr_index].@"break".operand;
+        const wr = try self.walkRef(file, scope, break_operand, false);
+
+        break :blk wr;
+    };
+
+    self.ast_nodes.items[self_ast_node_index].fields = param_ast_indexes.items;
+    const inst_data = data[inst_index].pl_node;
+
+    const extra = file.zir.extraData(Zir.Inst.ExtendedFunc, inst_data.payload_index);
+    var cc_index: ?usize = null;
+    if (extra.data.bits.has_cc) {
+        const cc_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra.end]);
+        cc_index = self.exprs.items.len;
+        _ = try self.walkRef(file, scope, cc_ref, false);
+    }
+
+    self.types.items[type_slot_index] = .{
+        .Fn = .{
+            .name = "todo_name func",
+            .src = self_ast_node_index,
+            .params = param_type_refs.items,
+            .ret = ret_type_ref.expr,
+            .is_extern = extra.data.bits.is_extern,
+            .has_cc = extra.data.bits.has_cc,
+            .is_inferred_error = extra.data.bits.is_inferred_error,
+            .cc = cc_index,
+        },
+    };
+
+    return DocData.WalkResult{
+        .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+        .expr = .{ .type = type_slot_index },
+    };
+}
 fn analyzeFunction(
     self: *Autodoc,
     file: *File,
@@ -2763,46 +2884,13 @@ fn analyzeFunction(
     };
 
     self.ast_nodes.items[self_ast_node_index].fields = param_ast_indexes.items;
-    self.types.items[type_slot_index] = switch (tags[inst_index]) {
-        .func, .func_inferred => blk: {
-            break :blk .{
-                .Fn = .{
-                    .name = "todo_name func",
-                    .src = self_ast_node_index,
-                    .params = param_type_refs.items,
-                    .ret = ret_type_ref.expr,
-                },
-            };
+    self.types.items[type_slot_index] = .{
+        .Fn = .{
+            .name = "todo_name func",
+            .src = self_ast_node_index,
+            .params = param_type_refs.items,
+            .ret = ret_type_ref.expr,
         },
-        .func_extended => blk: {
-            const inst_data = data[inst_index].pl_node;
-            const extra = file.zir.extraData(Zir.Inst.ExtendedFunc, inst_data.payload_index);
-            var cc_index: ?usize = null;
-            cc_index = self.types.items.len - 1;
-            // if (extra.data.bits.has_cc) {
-            //     const cc = file.zir.extra[extra.end];
-            //     const cc_ref = @intToEnum(Zir.Inst.Ref, cc);
-            //     _ = try self.walkRef(file, scope, cc_ref, false);
-            //     cc_index = self.types.items.len - 1;
-            //     std.debug.print("DONE\n", .{});
-            //     std.debug.print("cc_ref = {any}\n", .{cc_ref});
-            //     std.debug.print("index = {}\n", .{cc_index});
-            // }
-
-            break :blk .{
-                .Fn = .{
-                    .name = "todo_name func",
-                    .src = self_ast_node_index,
-                    .params = param_type_refs.items,
-                    .ret = ret_type_ref.expr,
-                    .is_extern = extra.data.bits.is_extern,
-                    .has_cc = extra.data.bits.has_cc,
-                    .is_inferred_error = extra.data.bits.is_inferred_error,
-                    .cc = cc_index,
-                },
-            };
-        },
-        else => unreachable,
     };
 
     return DocData.WalkResult{
@@ -3032,22 +3120,22 @@ fn walkRef(
             // TODO: dunno what to do with those
             .calling_convention_type => {
                 return DocData.WalkResult{
-                    // .typeRef = .{ .type = @enumToInt(Ref.calling_convention_type) },
-                    .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+                    .typeRef = .{ .type = @enumToInt(Ref.calling_convention_type) },
+                    // .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
                     .expr = .{ .int = .{ .value = 1 } },
                 };
             },
             .calling_convention_c => {
                 return DocData.WalkResult{
-                    // .typeRef = .{ .type = @enumToInt(Ref.calling_convention_c) },
-                    .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+                    .typeRef = .{ .type = @enumToInt(Ref.calling_convention_c) },
+                    // .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
                     .expr = .{ .int = .{ .value = 1 } },
                 };
             },
             .calling_convention_inline => {
                 return DocData.WalkResult{
-                    // .typeRef = .{ .type = @enumToInt(Ref.calling_convention_inline) },
-                    .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+                    .typeRef = .{ .type = @enumToInt(Ref.calling_convention_inline) },
+                    // .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
                     .expr = .{ .int = .{ .value = 1 } },
                 };
             },

From b823f011412fdb3e168c5c093bbb5c47983e74bf Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sat, 28 May 2022 19:47:12 -0300
Subject: [PATCH 080/137] add: extra information in extendedFn

---
 lib/docs/main.js | 14 ++++++++++++--
 src/Autodoc.zig  | 34 ++++++++++++++++++++++------------
 2 files changed, 34 insertions(+), 14 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 22f9b36382..7dfa4714fa 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1374,7 +1374,10 @@ var zigAnalysis;
                       let payloadHtml = "";
                       if (opts.wantHtml) {
                           if (fnObj.is_extern) {
-                            payloadHtml += "pub \"extern\" ";
+                            payloadHtml += "pub extern ";
+                          }
+                          if (fnObj.has_lib_name) {
+                            payloadHtml += "\"" + fnObj.lib_name +"\" ";
                           }
                           payloadHtml += 'fn';
                           if (opts.fnDecl) {
@@ -1523,9 +1526,16 @@ var zigAnalysis;
                           }
 
                       payloadHtml += ') ';
+
+                    if (fnObj.has_align) {
+                      let align = zigAnalysis.exprs[fnObj.align]
+                      payloadHtml += "align(" + exprName(align, opts) + ") ";
+                    }
                     if (fnObj.has_cc) {
                       let cc = zigAnalysis.exprs[fnObj.cc]
-                      payloadHtml += "callconv(." + cc.enumLiteral + ") ";
+                      if (cc) {
+                        payloadHtml += "callconv(." + cc.enumLiteral + ") ";
+                      }
                     }
 
                       if (fnObj.is_inferred_error) {
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index a278b53209..f5767f9d47 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -467,11 +467,13 @@ const DocData = struct {
             src: ?usize = null, // index into astNodes
             ret: Expr,
             params: ?[]Expr = null, // (use src->fields to find names)
+            lib_name: []const u8 = "",
             is_var_args: bool = false,
             is_inferred_error: bool = false,
             has_lib_name: bool = false,
             has_cc: bool = false,
             cc: ?usize = null,
+            @"align": ?usize = null,
             has_align: bool = false,
             is_test: bool = false,
             is_extern: bool = false,
@@ -2771,27 +2773,35 @@ fn analyzeFunctionExtended(
     };
 
     self.ast_nodes.items[self_ast_node_index].fields = param_ast_indexes.items;
-    const inst_data = data[inst_index].pl_node;
 
+    const inst_data = data[inst_index].pl_node;
     const extra = file.zir.extraData(Zir.Inst.ExtendedFunc, inst_data.payload_index);
+
+    var extra_index: usize = extra.end;
+
+    var lib_name: []const u8 = "";
+    if (extra.data.bits.has_lib_name) {
+        lib_name = file.zir.nullTerminatedString(file.zir.extra[extra_index]);
+        extra_index += 1;
+    }
+
     var cc_index: ?usize = null;
+    var align_index: ?usize = null;
     if (extra.data.bits.has_cc) {
-        const cc_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra.end]);
+        const cc_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
         cc_index = self.exprs.items.len;
         _ = try self.walkRef(file, scope, cc_ref, false);
+        extra_index += 1;
+    }
+
+    if (extra.data.bits.has_align) {
+        const align_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
+        align_index = self.exprs.items.len;
+        _ = try self.walkRef(file, scope, align_ref, false);
     }
 
     self.types.items[type_slot_index] = .{
-        .Fn = .{
-            .name = "todo_name func",
-            .src = self_ast_node_index,
-            .params = param_type_refs.items,
-            .ret = ret_type_ref.expr,
-            .is_extern = extra.data.bits.is_extern,
-            .has_cc = extra.data.bits.has_cc,
-            .is_inferred_error = extra.data.bits.is_inferred_error,
-            .cc = cc_index,
-        },
+        .Fn = .{ .name = "todo_name func", .src = self_ast_node_index, .params = param_type_refs.items, .ret = ret_type_ref.expr, .is_extern = extra.data.bits.is_extern, .has_cc = extra.data.bits.has_cc, .has_align = extra.data.bits.has_align, .has_lib_name = extra.data.bits.has_lib_name, .lib_name = lib_name, .is_inferred_error = extra.data.bits.is_inferred_error, .cc = cc_index, .@"align" = align_index },
     };
 
     return DocData.WalkResult{

From b96bd33f5558225f249ecee86156a2b7dd029064 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sat, 28 May 2022 20:33:46 -0300
Subject: [PATCH 081/137] add: handling to extra information in ptr_type

---
 src/Autodoc.zig | 93 +++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 91 insertions(+), 2 deletions(-)

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index f5767f9d47..e99fe500f8 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -412,6 +412,10 @@ const DocData = struct {
             size: std.builtin.TypeInfo.Pointer.Size,
             child: Expr,
             sentinel: ?Expr = null,
+            @"align": ?Expr = null,
+            address_space: ?Expr = null,
+            bit_start: ?Expr = null,
+            host_size: ?Expr = null,
             is_allowzero: bool = false,
             is_mutable: bool = false,
             is_volatile: bool = false,
@@ -537,6 +541,38 @@ const DocData = struct {
                         try sentinel.jsonStringify(options, w);
                         try w.print(",", .{});
                     }
+                    if (v.@"align") |@"align"| {
+                        try w.print(
+                            \\"align":
+                        , .{});
+                        if (options.whitespace) |*ws| ws.indent_level += 1;
+                        try @"align".jsonStringify(options, w);
+                        try w.print(",", .{});
+                    }
+                    if (v.address_space) |address_space| {
+                        try w.print(
+                            \\"address_space":
+                        , .{});
+                        if (options.whitespace) |*ws| ws.indent_level += 1;
+                        try address_space.jsonStringify(options, w);
+                        try w.print(",", .{});
+                    }
+                    if (v.bit_start) |bit_start| {
+                        try w.print(
+                            \\"bit_start":
+                        , .{});
+                        if (options.whitespace) |*ws| ws.indent_level += 1;
+                        try bit_start.jsonStringify(options, w);
+                        try w.print(",", .{});
+                    }
+                    if (v.host_size) |host_size| {
+                        try w.print(
+                            \\"host_size":
+                        , .{});
+                        if (options.whitespace) |*ws| ws.indent_level += 1;
+                        try host_size.jsonStringify(options, w);
+                        try w.print(",", .{});
+                    }
                     if (options.whitespace) |ws| try ws.outputIndent(w);
                     try w.print(
                         \\"is_allowzero": {},
@@ -951,6 +987,7 @@ fn walkInstruction(
         .ptr_type => {
             const ptr = data[inst_index].ptr_type;
             const extra = file.zir.extraData(Zir.Inst.PtrType, ptr.payload_index);
+            var extra_index = extra.end;
 
             const type_slot_index = self.types.items.len;
             const elem_type_ref = try self.walkRef(
@@ -960,9 +997,61 @@ fn walkInstruction(
                 false,
             );
 
-            const sentinel: ?DocData.Expr = if (ptr.flags.has_sentinel) DocData.Expr{ .int = .{ .value = 0, .negated = false } } else null;
+            // @check if `addrspace`, `bit_start` and `host_size` really need to be
+            // present in json
+            var sentinel: ?DocData.Expr = null;
+            if (ptr.flags.has_sentinel) {
+                const ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
+                const ref_result = try self.walkRef(file, parent_scope, ref, false);
+                sentinel = ref_result.expr;
+                extra_index += 1;
+            }
+
+            var @"align": ?DocData.Expr = null;
+            if (ptr.flags.has_align) {
+                const ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
+                const ref_result = try self.walkRef(file, parent_scope, ref, false);
+                @"align" = ref_result.expr;
+                extra_index += 1;
+            }
+            var address_space: ?DocData.Expr = null;
+            if (ptr.flags.has_addrspace) {
+                const ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
+                const ref_result = try self.walkRef(file, parent_scope, ref, false);
+                address_space = ref_result.expr;
+                extra_index += 1;
+            }
+            var bit_start: ?DocData.Expr = null;
+            if (ptr.flags.has_bit_range) {
+                const ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
+                const ref_result = try self.walkRef(file, parent_scope, ref, false);
+                address_space = ref_result.expr;
+                extra_index += 1;
+            }
+
+            var host_size: ?DocData.Expr = null;
+            if (ptr.flags.has_bit_range) {
+                const ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
+                const ref_result = try self.walkRef(file, parent_scope, ref, false);
+                host_size = ref_result.expr;
+            }
+
             try self.types.append(self.arena, .{
-                .Pointer = .{ .size = ptr.size, .child = elem_type_ref.expr, .sentinel = sentinel, .is_mutable = ptr.flags.is_mutable, .has_align = ptr.flags.has_align, .has_sentinel = ptr.flags.has_sentinel, .is_volatile = ptr.flags.is_volatile, .has_addrspace = ptr.flags.has_addrspace, .has_bit_range = ptr.flags.has_bit_range },
+                .Pointer = .{
+                    .size = ptr.size,
+                    .child = elem_type_ref.expr,
+                    .has_align = ptr.flags.has_align,
+                    .@"align" = @"align",
+                    .has_addrspace = ptr.flags.has_addrspace,
+                    .address_space = address_space,
+                    .has_sentinel = ptr.flags.has_sentinel,
+                    .sentinel = sentinel,
+                    .is_mutable = ptr.flags.is_mutable,
+                    .is_volatile = ptr.flags.is_volatile,
+                    .has_bit_range = ptr.flags.has_bit_range,
+                    .bit_start = bit_start,
+                    .host_size = host_size,
+                },
             });
             return DocData.WalkResult{
                 .typeRef = .{ .type = @enumToInt(Ref.type_type) },

From d55761f07e58e128e6b1fa3ae033706875e5989c Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sat, 28 May 2022 20:34:05 -0300
Subject: [PATCH 082/137] fix: print align() in pointers

---
 lib/docs/main.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 7dfa4714fa..a804da0c1c 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1257,15 +1257,16 @@ var zigAnalysis;
                               name += ") ";
                       }
                       if (ptrObj.has_align) {
+                          let align = exprName(ptrObj.align, opts);
                           if (opts.wantHtml) {
                               name += 'align(';
                           } else {
                               name += "align(";
                           }
                           if (opts.wantHtml) {
-                              name += '' + ptrObj.align + '';
+                              name += '' + align + '';
                           } else {
-                              name += ptrObj.align;
+                              name += align;
                           }
                           if (ptrObj.hostIntBytes != null) {
                               name += ":";

From c0c992525597a1e74768cdcc67cf2a61181cb72b Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sat, 28 May 2022 21:01:37 -0300
Subject: [PATCH 083/137] fix: apparently doing this the `@as` problem is
 solved @check

---
 lib/docs/main.js | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index a804da0c1c..ee2d8ac4b4 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1147,10 +1147,11 @@ var zigAnalysis;
               return payloadHtml;
           }
           case "as": {
-              const typeRefArg = zigAnalysis.exprs[expr.as.typeRefArg];
+              // const typeRefArg = zigAnalysis.exprs[expr.as.typeRefArg];
               const exprArg = zigAnalysis.exprs[expr.as.exprArg];
-              return "@as(" + exprName(typeRefArg, opts) +
-                ", " + exprName(exprArg, opts) + ")";
+              // return "@as(" + exprName(typeRefArg, opts) +
+              //   ", " + exprName(exprArg, opts) + ")";
+              return exprName(exprArg, opts);
           }
           case "declRef": {
             return zigAnalysis.decls[expr.declRef].name;

From 9f6bdc4bbeb0065940d7dbb81107161802cea917 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sun, 29 May 2022 03:36:02 -0300
Subject: [PATCH 084/137] add: binOp WIP

---
 lib/docs/main.js |  91 ++++++++++
 src/Autodoc.zig  | 430 ++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 519 insertions(+), 2 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index ee2d8ac4b4..2de584a666 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1062,6 +1062,97 @@ var zigAnalysis;
     function exprName(expr, opts) {
         switch (Object.keys(expr)[0]) {
           default: throw "oh no";
+          case "sizeOf" : {
+            const sizeOf = zigAnalysis.exprs[expr.sizeOf];
+            return "sizeOf(" + exprName(sizeOf, opts) + ")";
+          }
+          case "binOpIndex" : {
+            const binOpIndex = zigAnalysis.exprs[expr.binOpIndex];
+            return exprName(binOpIndex, opts);
+          }
+          case "binOp": {
+            const lhsOp = zigAnalysis.exprs[expr.binOp.lhs];
+            const rhsOp = zigAnalysis.exprs[expr.binOp.rhs];
+            let lhs = exprName(lhsOp, opts);
+            let rhs = exprName(rhsOp, opts);
+
+            let print_lhs = "";
+            let print_rhs = "";
+            if (lhsOp['binOpIndex']) {
+              print_lhs = "(" + lhs + ")";
+            } else {
+              print_lhs = lhs;
+            }
+            if (rhsOp['binOpIndex']) {
+              print_rhs = "(" + rhs + ")";
+            } else {
+              print_rhs = rhs;
+            }
+
+            let operator = "";
+            // binOp.kind is described at Autodoc.zig
+            // Expr section in BinOp struct
+            switch (expr.binOp.opKind) {
+              case 0: {
+                operator += "+";
+                break;
+              }
+              case 1: {
+                operator += "-";
+                break;
+              }
+              case 2: {
+                operator += "*";
+                break;
+              }
+              case 3: {
+                let print_div = "";
+                if (expr.binOp.exact) {
+                  print_div = "@divExact(";
+                }
+                if (expr.binOp.floor) {
+                  print_div = "@divFloor(";
+                }
+                if (expr.binOp.trunc) {
+                  print_div = "@divTrunc(";
+                }
+                return print_div + print_lhs + ", " + print_rhs + ")";
+              }
+              case 4: {
+                operator += "mod"
+                break;
+              }
+              case 5: {
+                operator += "rem"
+                break;
+              }
+              case 6: {
+                operator += "<<";
+                break;
+              }
+              case 7: {
+                operator += ">>";
+                break;
+              }
+              case 8: {
+                operator += "&";
+                break;
+              }
+              case 7: {
+                operator += "|";
+                break;
+              }
+              default: console.log("operator not handled yet or doesn't exist!");
+            };
+            if (expr.binOp.wrap) {
+              operator += "%";
+            }
+            if (expr.binOp.sat) {
+              operator += "|";
+            }
+            return print_lhs + " " + operator + " " + print_rhs;
+
+          }
           case "errorUnion": {
             const errUnionObj = zigAnalysis.types[expr.errorUnion];
             let lhs = exprName(errUnionObj.lhs, opts);
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index e99fe500f8..ea65078f59 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -655,6 +655,28 @@ const DocData = struct {
         sizeOf: usize, // index in `exprs`
         compileError: []const u8,
         string: []const u8, // direct value
+        // Index a `type` like struct with expressions
+        // it's necessary because when a caller ask by a binOp maybe there are
+        // more binary op inside them, so the caller get's the current `exprs` index
+        // and the binOp can walk the tree preserving the first index of the tree
+        // for examples see `.mul` and `analyzeFunctionExtended` in `has_align` section
+        binOp: BinOp,
+        binOpIndex: usize,
+        const BinOp = struct {
+            lhs: usize, // index in `exprs`
+            rhs: usize, // index in `exprs`
+            // opKind
+            // Identify the operator in js
+            // 0: add, 1: sub, 2: mul, 3: div, 4: mod, 5: rem, 6: shl, 7: shr, 8: bitwise_and, 9: bitwise_or
+            // Others binOp are not handled yet
+            opKind: usize = 0,
+            // flags to operations
+            wrap: bool = false,
+            sat: bool = false,
+            exact: bool = false,
+            floor: bool = false,
+            trunc: bool = false,
+        };
         const As = struct {
             typeRefArg: ?usize, // index in `exprs`
             exprArg: usize, // index in `exprs`
@@ -701,7 +723,11 @@ const DocData = struct {
                         \\{{ "bool":{} }}
                     , .{v});
                 },
-                .sizeOf => |v| try std.json.stringify(v, options, w),
+                .sizeOf => |v| {
+                    try w.print(
+                        \\{{ "sizeOf":{} }}
+                    , .{v});
+                },
                 .fieldRef => |v| try std.json.stringify(
                     struct { fieldRef: FieldRef }{ .fieldRef = v },
                     options,
@@ -725,6 +751,16 @@ const DocData = struct {
                         try w.print("{s}", .{comma});
                     }
                 },
+                .binOp => |v| try std.json.stringify(
+                    struct { binOp: BinOp }{ .binOp = v },
+                    options,
+                    w,
+                ),
+                .binOpIndex => |v| try std.json.stringify(
+                    struct { binOpIndex: usize }{ .binOpIndex = v },
+                    options,
+                    w,
+                ),
                 .typeOf_peer => |v| try std.json.stringify(
                     struct { typeOf_peer: []usize }{ .typeOf_peer = v },
                     options,
@@ -931,6 +967,381 @@ fn walkInstruction(
                 .expr = .{ .int = .{ .value = int } },
             };
         },
+        .add => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 0 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+        .addwrap => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .wrap = true, .opKind = 0 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+        .add_sat => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .sat = true, .opKind = 0 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+
+        .sub => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 1 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+        .subwrap => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .wrap = true, .opKind = 1 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+        .sub_sat => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .sat = true, .opKind = 1 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+
+        .mul => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 2 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+        .mulwrap => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .wrap = true, .opKind = 2 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+        .mul_sat => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .sat = true, .opKind = 2 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+
+        .div_exact => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 3 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+        .div_floor => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .floor = true, .opKind = 3 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+        .div_trunc => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .trunc = true, .opKind = 3 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
         .error_union_type => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
@@ -1435,6 +1846,14 @@ fn walkInstruction(
             const dest_type_idx = self.exprs.items.len;
             try self.exprs.append(self.arena, dest_type_walk.expr);
 
+            const sep = "=" ** 200;
+            std.debug.print("{s}\n", .{sep});
+            std.debug.print("AS NODE\n", .{});
+            std.debug.print("extra = {any}\n", .{extra});
+            std.debug.print("desty_type_walk = {any}\n", .{dest_type_walk});
+            std.debug.print("operand = {any}\n", .{operand});
+            std.debug.print("{s}\n", .{sep});
+
             // TODO: there's something wrong with how both `as` and `WalkrResult`
             //       try to store type information.
             return DocData.WalkResult{
@@ -2886,7 +3305,14 @@ fn analyzeFunctionExtended(
     if (extra.data.bits.has_align) {
         const align_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
         align_index = self.exprs.items.len;
-        _ = try self.walkRef(file, scope, align_ref, false);
+        const result = try self.walkRef(file, scope, align_ref, false);
+
+        const sep = "=" ** 200;
+        std.debug.print("{s}\n", .{sep});
+        std.debug.print("ALIGN\n", .{});
+        std.debug.print("align_ref = {any}\n", .{align_ref});
+        std.debug.print("result = {any}\n", .{result});
+        std.debug.print("{s}\n", .{sep});
     }
 
     self.types.items[type_slot_index] = .{

From 462f751902baefb68ff6f372263ed3b1637690d5 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sun, 29 May 2022 04:19:47 -0300
Subject: [PATCH 085/137] binOp now showing better it's need a better struture,
 right now it's has a hack one

---
 lib/docs/main.js |  32 +++---
 src/Autodoc.zig  | 273 ++++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 275 insertions(+), 30 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 2de584a666..1d8305c9dc 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1078,6 +1078,10 @@ var zigAnalysis;
 
             let print_lhs = "";
             let print_rhs = "";
+
+            console.log(lhsOp)
+            console.log(rhsOp)
+
             if (lhsOp['binOpIndex']) {
               print_lhs = "(" + lhs + ")";
             } else {
@@ -1119,27 +1123,29 @@ var zigAnalysis;
                 return print_div + print_lhs + ", " + print_rhs + ")";
               }
               case 4: {
-                operator += "mod"
-                break;
+                return "@mod(" + print_lhs + ", " + print_rhs + ")";
               }
               case 5: {
-                operator += "rem"
-                break;
+                return "@rem(" + print_lhs + ", " + print_rhs + ")";
               }
               case 6: {
+                // rem_mod
+                return "@rem(" + print_lhs + ", " + print_rhs + ")";
+              }
+              case 7: {
+                if (expr.binOp.exact) {
+                  let print_shl = "@shlExact(";
+                  return print_shl + print_lhs + ", " + print_rhs + ")";
+                }
                 operator += "<<";
                 break;
               }
-              case 7: {
-                operator += ">>";
-                break;
-              }
               case 8: {
-                operator += "&";
-                break;
-              }
-              case 7: {
-                operator += "|";
+                if (expr.binOp.exact) {
+                  let print_shr = "@shrExact(";
+                  return print_shr + print_lhs + ", " + print_rhs + ")";
+                }
+                operator += ">>";
                 break;
               }
               default: console.log("operator not handled yet or doesn't exist!");
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index ea65078f59..9077c80179 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -667,7 +667,7 @@ const DocData = struct {
             rhs: usize, // index in `exprs`
             // opKind
             // Identify the operator in js
-            // 0: add, 1: sub, 2: mul, 3: div, 4: mod, 5: rem, 6: shl, 7: shr, 8: bitwise_and, 9: bitwise_or
+            // 0: add, 1: sub, 2: mul, 3: div, 4: mod, 5: rem, 6: rem_mod, 7: shl, 8: shr
             // Others binOp are not handled yet
             opKind: usize = 0,
             // flags to operations
@@ -1342,6 +1342,260 @@ fn walkInstruction(
                 .expr = .{ .binOpIndex = binop_index },
             };
         },
+
+        .mod => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 4 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+        .rem => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .floor = true, .opKind = 5 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+
+        // @check how to test it
+        .mod_rem => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .floor = true, .opKind = 6 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+
+        .shl => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 7 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+        .shl_exact => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 7 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+        .shl_sat => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .sat = true, .opKind = 7 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+
+        .shr => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 8 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+        .shr_exact => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 8 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+
         .error_union_type => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
@@ -1846,14 +2100,6 @@ fn walkInstruction(
             const dest_type_idx = self.exprs.items.len;
             try self.exprs.append(self.arena, dest_type_walk.expr);
 
-            const sep = "=" ** 200;
-            std.debug.print("{s}\n", .{sep});
-            std.debug.print("AS NODE\n", .{});
-            std.debug.print("extra = {any}\n", .{extra});
-            std.debug.print("desty_type_walk = {any}\n", .{dest_type_walk});
-            std.debug.print("operand = {any}\n", .{operand});
-            std.debug.print("{s}\n", .{sep});
-
             // TODO: there's something wrong with how both `as` and `WalkrResult`
             //       try to store type information.
             return DocData.WalkResult{
@@ -3305,14 +3551,7 @@ fn analyzeFunctionExtended(
     if (extra.data.bits.has_align) {
         const align_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
         align_index = self.exprs.items.len;
-        const result = try self.walkRef(file, scope, align_ref, false);
-
-        const sep = "=" ** 200;
-        std.debug.print("{s}\n", .{sep});
-        std.debug.print("ALIGN\n", .{});
-        std.debug.print("align_ref = {any}\n", .{align_ref});
-        std.debug.print("result = {any}\n", .{result});
-        std.debug.print("{s}\n", .{sep});
+        _ = try self.walkRef(file, scope, align_ref, false);
     }
 
     self.types.items[type_slot_index] = .{

From d23ccdb8d9e4d3510667164545f9c3be3374d529 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sun, 29 May 2022 05:22:41 -0300
Subject: [PATCH 086/137] fix: "match failure" in c.zig file @check other files
 and handling floats and undefined values in js

---
 lib/docs/main.js | 6 ++++++
 src/Autodoc.zig  | 4 +++-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 1d8305c9dc..50e5a5865b 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1259,6 +1259,12 @@ var zigAnalysis;
           case "int": {
               return "" + expr.int;
           }
+          case "float": {
+              return "" + expr.float.toFixed(2);
+          }
+          case "undefined": {
+              return "undefined";
+          }
           case "string": {
             return "\"" + escapeHtml(expr.string) + "\"";
           }
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 9077c80179..e07c2a9b29 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -3423,7 +3423,9 @@ fn tryResolveRefPath(
                         "failed to match `{s}` in struct",
                         .{child_string},
                     );
-                    path[i + 1] = (try self.cteTodo("match failure")).expr;
+                    // path[i + 1] = (try self.cteTodo("match failure")).expr;
+                    // this are working, check c.zig
+                    path[i + 1] = (try self.cteTodo(child_string)).expr;
                     continue :outer;
                 },
             },

From 1213123ad04e90d67b5c004ddc8744fe409cd839 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sun, 29 May 2022 05:56:26 -0300
Subject: [PATCH 087/137] fix: *.{} array are now printed as type *[]comptime

---
 lib/docs/main.js |  3 +++
 src/Autodoc.zig  | 21 +++++++++------------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 50e5a5865b..0be071f4fc 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1329,6 +1329,9 @@ var zigAnalysis;
                               name += is_mutable;
                               break;
                           case pointerSizeEnum.Slice:
+                              if (ptrObj.is_ref) {
+                                name += "*";
+                              }
                               name += "[";
                               name += sentinel;
                               name += "]";
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index e07c2a9b29..d29a468b91 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -416,6 +416,7 @@ const DocData = struct {
             address_space: ?Expr = null,
             bit_start: ?Expr = null,
             host_size: ?Expr = null,
+            is_ref: bool = false,
             is_allowzero: bool = false,
             is_mutable: bool = false,
             is_volatile: bool = false,
@@ -582,8 +583,9 @@ const DocData = struct {
                         \\"has_align": {},
                         \\"has_addrspace": {},
                         \\"has_bit_range": {},
+                        \\"is_ref": {},
                         \\
-                    , .{ v.is_allowzero, v.is_mutable, v.is_volatile, v.has_sentinel, v.has_align, v.has_addrspace, v.has_bit_range });
+                    , .{ v.is_allowzero, v.is_mutable, v.is_volatile, v.has_sentinel, v.has_align, v.has_addrspace, v.has_bit_range, v.is_ref });
                     if (options.whitespace) |ws| try ws.outputIndent(w);
                     try w.print(
                         \\"child":
@@ -1962,17 +1964,12 @@ fn walkInstruction(
             }
 
             const type_slot_index = self.types.items.len;
-            try self.types.append(self.arena, .{
-                .Array = .{
-                    .len = .{
-                        .int = .{
-                            .value = operands.len - 1,
-                            .negated = false,
-                        },
-                    },
-                    .child = array_type.?,
-                },
-            });
+            try self.types.append(self.arena, .{ .Pointer = .{
+                .size = .Slice,
+                .child = array_type.?,
+                .is_mutable = true,
+                .is_ref = true,
+            } });
 
             return DocData.WalkResult{
                 .typeRef = .{ .type = type_slot_index },

From d5d27f245b63b4b516db09feb334e4f548c89b1b Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sun, 29 May 2022 06:08:30 -0300
Subject: [PATCH 088/137] issue: reminder to fix array_init

---
 src/Autodoc.zig | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index d29a468b91..b56115372a 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -1788,6 +1788,14 @@ fn walkInstruction(
                 array_data[idx] = wr.expr.as.exprArg;
             }
 
+            // @check
+            // not working with
+            // const value_slice_float = []f32{42.0};
+            // const value_slice_float2: []f32 = .{42.0};
+            // rendering [][]f32
+            // the reason for that is it's initialized as a pointer
+            // in this case getting the last type index works fine
+            // but when it's not after a pointer it's thrown an error in js.
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{ .Pointer = .{
                 .size = .Slice,

From 8e835fd3a2ca4a434c7b1971b39ddc9d60263d26 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sun, 29 May 2022 06:27:03 -0300
Subject: [PATCH 089/137] add: handling binOp div

---
 lib/docs/main.js |  4 ++++
 src/Autodoc.zig  | 31 +++++++++++++++++++++++++++++++
 2 files changed, 35 insertions(+)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 0be071f4fc..b217cc462f 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1110,6 +1110,10 @@ var zigAnalysis;
                 break;
               }
               case 3: {
+                if (!expr.binOp.extact && !expr.binOp.floor && !expr.binOp.trunv) {
+                  operator += "/";
+                  break;
+                }
                 let print_div = "";
                 if (expr.binOp.exact) {
                   print_div = "@divExact(";
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index b56115372a..abfb5ea3cb 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -1251,6 +1251,37 @@ fn walkInstruction(
             };
         },
 
+        .div => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 3 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
         .div_exact => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);

From f59bb65ff52363c4d32a00852daeed711934e312 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sun, 29 May 2022 12:59:54 -0300
Subject: [PATCH 090/137] add: handling @bitCast as binOp

---
 lib/docs/main.js |  3 +++
 src/Autodoc.zig  | 33 ++++++++++++++++++++++++++++++++-
 2 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index b217cc462f..6a3e3bd0ef 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1152,6 +1152,9 @@ var zigAnalysis;
                 operator += ">>";
                 break;
               }
+              case 9 : {
+                return "@bitCast(" + print_lhs + ", " + print_rhs + ")";
+              }
               default: console.log("operator not handled yet or doesn't exist!");
             };
             if (expr.binOp.wrap) {
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index abfb5ea3cb..eed8fcc37f 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -669,7 +669,7 @@ const DocData = struct {
             rhs: usize, // index in `exprs`
             // opKind
             // Identify the operator in js
-            // 0: add, 1: sub, 2: mul, 3: div, 4: mod, 5: rem, 6: rem_mod, 7: shl, 8: shr
+            // 0: add, 1: sub, 2: mul, 3: div, 4: mod, 5: rem, 6: rem_mod, 7: shl, 8: shr, 9: bitcast
             // Others binOp are not handled yet
             opKind: usize = 0,
             // flags to operations
@@ -969,6 +969,37 @@ fn walkInstruction(
                 .expr = .{ .int = .{ .value = int } },
             };
         },
+        .bitcast => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 9 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
         .add => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);

From a529d747c9e4b2064fa3e399025c804e05e5fdf5 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sun, 29 May 2022 13:18:28 -0300
Subject: [PATCH 091/137] add: binOp @alignCast and bit_or

---
 lib/docs/main.js |  7 ++++++
 src/Autodoc.zig  | 64 +++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 70 insertions(+), 1 deletion(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 6a3e3bd0ef..12cd00a151 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1155,6 +1155,13 @@ var zigAnalysis;
               case 9 : {
                 return "@bitCast(" + print_lhs + ", " + print_rhs + ")";
               }
+              case 10 : {
+                operator += "|";
+                break;
+              }
+              case 11 : {
+                return "@alignCast(" + print_lhs + ", " + print_rhs + ")";
+              }
               default: console.log("operator not handled yet or doesn't exist!");
             };
             if (expr.binOp.wrap) {
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index eed8fcc37f..6e51938065 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -669,7 +669,7 @@ const DocData = struct {
             rhs: usize, // index in `exprs`
             // opKind
             // Identify the operator in js
-            // 0: add, 1: sub, 2: mul, 3: div, 4: mod, 5: rem, 6: rem_mod, 7: shl, 8: shr, 9: bitcast
+            // 0: add, 1: sub, 2: mul, 3: div, 4: mod, 5: rem, 6: rem_mod, 7: shl, 8: shr, 9: bitcast, 10: bit_or, 11: align_cast
             // Others binOp are not handled yet
             opKind: usize = 0,
             // flags to operations
@@ -1000,6 +1000,68 @@ fn walkInstruction(
                 .expr = .{ .binOpIndex = binop_index },
             };
         },
+        .align_cast => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 11 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+        .bit_or => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 10 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
         .add => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);

From 5fcf0b056544c32f30c4aa3bfe884fc3a9c675f1 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sun, 29 May 2022 13:31:47 -0300
Subject: [PATCH 092/137] add: handling @bitSizeOf() need to check why not
 working correctly with `align()`

---
 lib/docs/main.js |  4 ++++
 src/Autodoc.zig  | 22 ++++++++++++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 12cd00a151..835b4a644b 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1062,6 +1062,10 @@ var zigAnalysis;
     function exprName(expr, opts) {
         switch (Object.keys(expr)[0]) {
           default: throw "oh no";
+          case "bitSizeOf" : {
+            const bitSizeOf = zigAnalysis.exprs[expr.bitSizeOf];
+            return "@bitSizeOf(" + exprName(bitSizeOf, opts) + ")";
+          }
           case "sizeOf" : {
             const sizeOf = zigAnalysis.exprs[expr.sizeOf];
             return "sizeOf(" + exprName(sizeOf, opts) + ")";
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 6e51938065..53499dd838 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -655,6 +655,7 @@ const DocData = struct {
         errorUnion: usize, // index in `exprs`
         as: As,
         sizeOf: usize, // index in `exprs`
+        bitSizeOf: usize, // index in `exprs`
         compileError: []const u8,
         string: []const u8, // direct value
         // Index a `type` like struct with expressions
@@ -730,6 +731,11 @@ const DocData = struct {
                         \\{{ "sizeOf":{} }}
                     , .{v});
                 },
+                .bitSizeOf => |v| {
+                    try w.print(
+                        \\{{ "bitSizeOf":{} }}
+                    , .{v});
+                },
                 .fieldRef => |v| try std.json.stringify(
                     struct { fieldRef: FieldRef }{ .fieldRef = v },
                     options,
@@ -2151,6 +2157,22 @@ fn walkInstruction(
                 .expr = .{ .sizeOf = operand_index },
             };
         },
+        .bit_size_of => {
+            // not working correctly with `align()`
+            const un_node = data[inst_index].un_node;
+            const operand = try self.walkRef(
+                file,
+                parent_scope,
+                un_node.operand,
+                false,
+            );
+            const operand_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, operand.expr);
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+                .expr = .{ .bitSizeOf = operand_index },
+            };
+        },
 
         .typeof => {
             const un_node = data[inst_index].un_node;

From 9be9e4d02c059e55c476fd98e789bbc02c08730a Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Sun, 29 May 2022 14:10:33 -0300
Subject: [PATCH 093/137] add: @enumToInt() WIP

---
 lib/docs/main.js | 16 +++++++++++++++-
 src/Autodoc.zig  | 26 ++++++++++++++++++++++++++
 2 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 835b4a644b..12161b80d3 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1062,13 +1062,27 @@ var zigAnalysis;
     function exprName(expr, opts) {
         switch (Object.keys(expr)[0]) {
           default: throw "oh no";
+          case "fieldRef" : {
+            // const fieldRef = zigAnalysis.decls[expr.fieldRef.index];
+            // const struct_name = zigAnalysis.decls[expr.struct[0].val.typeRef.refPath[0].declRef].name;
+            console.log(expr)
+            console.log(fieldRef)
+            // return "@enumToInt(" + exprName(enumToInt, opts) + ")";
+            // return exprName(fieldRef,opts);
+            return "WIP"
+          }
+          case "enumToInt" : {
+            console.log(expr);
+            const enumToInt = zigAnalysis.exprs[expr.enumToInt];
+            return "@enumToInt(" + exprName(enumToInt, opts) + ")";
+          }
           case "bitSizeOf" : {
             const bitSizeOf = zigAnalysis.exprs[expr.bitSizeOf];
             return "@bitSizeOf(" + exprName(bitSizeOf, opts) + ")";
           }
           case "sizeOf" : {
             const sizeOf = zigAnalysis.exprs[expr.sizeOf];
-            return "sizeOf(" + exprName(sizeOf, opts) + ")";
+            return "@sizeOf(" + exprName(sizeOf, opts) + ")";
           }
           case "binOpIndex" : {
             const binOpIndex = zigAnalysis.exprs[expr.binOpIndex];
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 53499dd838..221b8aa0b9 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -656,6 +656,7 @@ const DocData = struct {
         as: As,
         sizeOf: usize, // index in `exprs`
         bitSizeOf: usize, // index in `exprs`
+        enumToInt: usize, // index in `exprs`
         compileError: []const u8,
         string: []const u8, // direct value
         // Index a `type` like struct with expressions
@@ -736,6 +737,11 @@ const DocData = struct {
                         \\{{ "bitSizeOf":{} }}
                     , .{v});
                 },
+                .enumToInt => |v| {
+                    try w.print(
+                        \\{{ "enumToInt":{} }}
+                    , .{v});
+                },
                 .fieldRef => |v| try std.json.stringify(
                     struct { fieldRef: FieldRef }{ .fieldRef = v },
                     options,
@@ -2173,6 +2179,26 @@ fn walkInstruction(
                 .expr = .{ .bitSizeOf = operand_index },
             };
         },
+        .enum_to_int => {
+            // not working correctly with `align()`
+            const un_node = data[inst_index].un_node;
+            const operand = try self.walkRef(
+                file,
+                parent_scope,
+                un_node.operand,
+                false,
+            );
+            const operand_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, operand.expr);
+
+            std.debug.print("un_node = {any}\n", .{un_node});
+            std.debug.print("operand = {any}\n", .{operand});
+            std.debug.print("operand_expr = {any}\n", .{operand.expr});
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+                .expr = .{ .enumToInt = operand_index },
+            };
+        },
 
         .typeof => {
             const un_node = data[inst_index].un_node;

From f07534069deaa500df075ca6424f4bce29dcd7f8 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Mon, 30 May 2022 15:45:57 -0300
Subject: [PATCH 094/137] WIP: switch_block tag

---
 lib/docs/main.js |  30 ++++++++++
 src/Autodoc.zig  | 151 +++++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 176 insertions(+), 5 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 12161b80d3..520457c3d1 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1062,6 +1062,36 @@ var zigAnalysis;
     function exprName(expr, opts) {
         switch (Object.keys(expr)[0]) {
           default: throw "oh no";
+          case "enumLiteral": {
+            let literal = expr.enumLiteral;
+            return literal;
+          }
+          case "switchOp":{
+            let payloadHtml = "switch() {
    ";
+            for (let i = 0; i < expr.switchOp.cases.length; i++) {
+              const caseIndex = expr.switchOp.cases[i];
+              const item = zigAnalysis.exprs[caseIndex];
+              console.log(caseIndex);
+              console.log(item);
+              if (item['enumLiteral']) {
+                payloadHtml += "   " + " ." + exprName(item, opts) + " = " + "
    ";
+                continue;
+              }
+              payloadHtml += "    " + exprName(item, opts) + " = " + "
    ";
+            }
+              if (expr.switchOp.else_index !== 0) {
+                const else_index = expr.switchOp.else_index;
+                const item = zigAnalysis.exprs[else_index];
+                console.log(item);
+                payloadHtml += "    " + "else" + " = " + "
    ";
+              }
+              payloadHtml += "}";
+            return payloadHtml;
+          }
+          case "switchIndex": {
+            const switchIndex = zigAnalysis.exprs[expr.switchIndex];
+            return exprName(switchIndex, opts);
+          }
           case "fieldRef" : {
             // const fieldRef = zigAnalysis.decls[expr.fieldRef.index];
             // const struct_name = zigAnalysis.decls[expr.struct[0].val.typeRef.refPath[0].declRef].name;
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 221b8aa0b9..51293eeffd 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -659,6 +659,8 @@ const DocData = struct {
         enumToInt: usize, // index in `exprs`
         compileError: []const u8,
         string: []const u8, // direct value
+        switchIndex: usize, // index in `exprs`
+        switchOp: SwitchOp,
         // Index a `type` like struct with expressions
         // it's necessary because when a caller ask by a binOp maybe there are
         // more binary op inside them, so the caller get's the current `exprs` index
@@ -681,6 +683,13 @@ const DocData = struct {
             floor: bool = false,
             trunc: bool = false,
         };
+        const SwitchOp = struct {
+            cases: []usize,
+            else_index: ?usize,
+            // body_cases: ?[]usize,
+
+            // const Case = struct { lhs: Expr, rhs: Expr };
+        };
         const As = struct {
             typeRefArg: ?usize, // index in `exprs`
             exprArg: usize, // index in `exprs`
@@ -765,6 +774,16 @@ const DocData = struct {
                         try w.print("{s}", .{comma});
                     }
                 },
+                .switchOp => |v| try std.json.stringify(
+                    struct { switchOp: SwitchOp }{ .switchOp = v },
+                    options,
+                    w,
+                ),
+                .switchIndex => |v| try std.json.stringify(
+                    struct { switchIndex: usize }{ .switchIndex = v },
+                    options,
+                    w,
+                ),
                 .binOp => |v| try std.json.stringify(
                     struct { binOp: BinOp }{ .binOp = v },
                     options,
@@ -2170,12 +2189,13 @@ fn walkInstruction(
                 file,
                 parent_scope,
                 un_node.operand,
-                false,
+                need_type,
             );
             const operand_index = self.exprs.items.len;
             try self.exprs.append(self.arena, operand.expr);
+
             return DocData.WalkResult{
-                .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
+                .typeRef = operand.typeRef,
                 .expr = .{ .bitSizeOf = operand_index },
             };
         },
@@ -2191,14 +2211,135 @@ fn walkInstruction(
             const operand_index = self.exprs.items.len;
             try self.exprs.append(self.arena, operand.expr);
 
-            std.debug.print("un_node = {any}\n", .{un_node});
-            std.debug.print("operand = {any}\n", .{operand});
-            std.debug.print("operand_expr = {any}\n", .{operand.expr});
             return DocData.WalkResult{
                 .typeRef = .{ .type = @enumToInt(Ref.comptime_int_type) },
                 .expr = .{ .enumToInt = operand_index },
             };
         },
+        .switch_block => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.SwitchBlock, pl_node.payload_index);
+            const array_data = try self.arena.alloc(usize, extra.data.bits.scalar_cases_len);
+            var extra_index = extra.end;
+
+            const sep = "=" ** 200;
+            std.debug.print("{s}\n", .{sep});
+            std.debug.print("pl_node = {any}\n", .{pl_node});
+            std.debug.print("extra = {any}\n", .{extra});
+
+            const multi_cases_len = if (extra.data.bits.has_multi_cases) blk: {
+                const multi_cases_len = file.zir.extra[extra_index];
+                extra_index += 1;
+                break :blk multi_cases_len;
+            } else 0;
+
+            var else_index: ?usize = null;
+            const special_prong = extra.data.bits.specialProng();
+            if (special_prong != .none) {
+                const body_len = file.zir.extra[extra_index];
+                extra_index += 1;
+                const body = file.zir.extra[extra_index..][0..body_len];
+                extra_index += body.len;
+                for (body) |body_member| {
+                    const item_ref = @intToEnum(Ref, file.zir.extra[extra_index]);
+                    const item = try self.walkRef(file, parent_scope, item_ref, false);
+                    std.debug.print("prong item_ref = {any}\n", .{item_ref});
+                    std.debug.print("prong item = {any}\n", .{item});
+                    std.debug.print("body member = {any}\n", .{body_member});
+                    const item_index = self.exprs.items.len;
+                    try self.exprs.append(self.arena, item.expr);
+                    else_index = item_index;
+                }
+            }
+
+            // var array_type: ?DocData.Expr = null;
+            {
+                const scalar_cases_len = extra.data.bits.scalar_cases_len;
+                var scalar_i: usize = 0;
+                while (scalar_i < scalar_cases_len) : (scalar_i += 1) {
+                    const item_ref = @intToEnum(Ref, file.zir.extra[extra_index]);
+                    const item = try self.walkRef(file, parent_scope, item_ref, false);
+                    extra_index += 1;
+                    const body_len = file.zir.extra[extra_index];
+                    extra_index += 1;
+                    const body = file.zir.extra[extra_index..][0..body_len];
+                    extra_index += body_len;
+                    _ = body;
+                    array_data[scalar_i] = item.expr.as.exprArg;
+
+                    const body_ref = @intToEnum(Ref, file.zir.extra[extra_index]);
+                    const body_item = try self.walkRef(file, parent_scope, item_ref, false);
+
+                    array_data[scalar_i] = item.expr.as.exprArg;
+                    std.debug.print("{s}\n", .{sep});
+                    std.debug.print("body item_ref = {any}\n", .{item_ref});
+                    std.debug.print("body item = {any}\n", .{item});
+                    std.debug.print("body_len scalar cases = {any}\n", .{body_ref});
+                    std.debug.print("body scalar cases = {any}\n", .{body_item});
+                    std.debug.print("{s}\n", .{sep});
+                }
+            }
+            {
+                var multi_i: usize = 0;
+                while (multi_i < multi_cases_len) : (multi_i += 1) {
+                    const items_len = file.zir.extra[extra_index];
+                    extra_index += 1;
+                    const ranges_len = file.zir.extra[extra_index];
+                    extra_index += 1;
+                    const body_len = file.zir.extra[extra_index];
+                    extra_index += 1;
+                    const items = file.zir.refSlice(extra_index, items_len);
+                    extra_index += items_len;
+                    _ = items;
+
+                    var range_i: usize = 0;
+                    while (range_i < ranges_len) : (range_i += 1) {
+                        extra_index += 1;
+                        extra_index += 1;
+                    }
+
+                    const body = file.zir.extra[extra_index..][0..body_len];
+                    extra_index += body_len;
+
+                    std.debug.print("body multi_i = {any}\n", .{body});
+                    std.debug.print("items = {any}\n", .{items});
+                }
+            }
+
+            // std.debug.print("multi_cases_len = {}\n", .{multi_cases_len});
+            std.debug.print("{s}\n", .{sep});
+
+            const switch_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .switchOp = .{ .cases = array_data, .else_index = else_index } });
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .switchIndex = switch_index },
+            };
+        },
+        .switch_cond => {
+            const un_node = data[inst_index].un_node;
+            const operand = try self.walkRef(
+                file,
+                parent_scope,
+                un_node.operand,
+                need_type,
+            );
+            const operand_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, operand.expr);
+
+            // const sep = "=" ** 200;
+            // std.debug.print("{s}\n", .{sep});
+            // std.debug.print("SWITCH COND\n", .{});
+            // std.debug.print("un_node {any} \n", .{un_node});
+            // std.debug.print("operand {any} \n", .{operand});
+            // std.debug.print("{s}\n", .{sep});
+
+            return DocData.WalkResult{
+                .typeRef = operand.typeRef,
+                .expr = .{ .typeOf = operand_index },
+            };
+        },
 
         .typeof => {
             const un_node = data[inst_index].un_node;

From 51647c305eea1c38da47e3c20b39418ce3a7689f Mon Sep 17 00:00:00 2001
From: Loris Cro 
Date: Mon, 30 May 2022 16:48:34 +0200
Subject: [PATCH 095/137] autodoc: add buffering to the json writer

---
 src/Autodoc.zig | 39 +++++++++++++++++++++++----------------
 1 file changed, 23 insertions(+), 16 deletions(-)

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 51293eeffd..44234d31db 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -219,22 +219,29 @@ pub fn generateZirData(self: *Autodoc) !void {
         (d.handle.openDir(self.doc_location.basename, .{}) catch unreachable)
     else
         (self.module.zig_cache_artifact_directory.handle.openDir(self.doc_location.basename, .{}) catch unreachable);
-    const data_js_f = output_dir.createFile("data.js", .{}) catch unreachable;
-    defer data_js_f.close();
-    const out = data_js_f.writer();
-    out.print(
-        \\ /** @type {{DocData}} */
-        \\ var zigAnalysis=
-    , .{}) catch unreachable;
-    std.json.stringify(
-        data,
-        .{
-            .whitespace = .{},
-            .emit_null_optional_fields = false,
-        },
-        out,
-    ) catch unreachable;
-    out.print(";", .{}) catch unreachable;
+    {
+        const data_js_f = output_dir.createFile("data.js", .{}) catch unreachable;
+        defer data_js_f.close();
+        var buffer = std.io.bufferedWriter(data_js_f.writer());
+
+        const out = buffer.writer();
+        out.print(
+            \\ /** @type {{DocData}} */
+            \\ var zigAnalysis=
+        , .{}) catch unreachable;
+        std.json.stringify(
+            data,
+            .{
+                .whitespace = .{},
+                .emit_null_optional_fields = false,
+            },
+            out,
+        ) catch unreachable;
+        out.print(";", .{}) catch unreachable;
+
+        // last thing (that can fail) that we do is flush
+        buffer.flush() catch unreachable;
+    }
     // copy main.js, index.html
     const docs = try self.module.comp.zig_lib_directory.join(self.arena, &.{ "docs", std.fs.path.sep_str });
     var docs_dir = std.fs.openDirAbsolute(docs, .{}) catch unreachable;

From 413cfd4066c547ec1cf3c7b81b0ca34e9eddb82a Mon Sep 17 00:00:00 2001
From: Loris Cro 
Date: Mon, 30 May 2022 21:48:46 +0200
Subject: [PATCH 096/137] autodoc: init generic function support

---
 lib/docs/main.js | 35 ++++++++++++++++++++++++++--------
 src/Autodoc.zig  | 49 +++++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 73 insertions(+), 11 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 520457c3d1..d37dea5200 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -724,7 +724,7 @@ var zigAnalysis;
         if (typeObj.kind !== typeKinds.Fn) {
             return false;
         }
-        return  /** @type {Fn} */(typeObj).generic;
+        return  /** @type {Fn} */(typeObj).generic_ret != null;
     }
 
     /** @param {Decl} fnDecl */
@@ -772,7 +772,26 @@ var zigAnalysis;
 
         let protoSrcIndex = fnDecl.src;
         if (typeIsGenericFn(value.expr.type)) {
-            throw "TODO";
+            // does the generic_ret contain a container?
+            var resolvedGenericRet = resolveValue({expr: typeObj.generic_ret});
+            // TODO: see if unwrapping the `as` here is a good idea or not.
+            if ("as" in resolvedGenericRet.expr) {
+                resolvedGenericRet = {
+                    expr: zigAnalysis.exprs[resolvedGenericRet.expr.as.exprArg]
+                };
+            }
+
+            if (!("type" in resolvedGenericRet.expr)) return;
+            const genericType = zigAnalysis.types[resolvedGenericRet.expr.type];
+            if (isContainerType(genericType)) {
+                renderContainer(genericType)
+            }
+
+
+
+
+
+            // old code
             // let instantiations = nodesToFnsMap[protoSrcIndex];
             // let calls = nodesToCallsMap[protoSrcIndex];
             // if (instantiations == null && calls == null) {
@@ -1530,7 +1549,7 @@ var zigAnalysis;
                         return html;
                       }
                   }
-                  
+
                   case typeKinds.ErrorUnion:
                   {
                     let errUnionObj = /** @type {ErrUnionType} */(typeObj);
@@ -1614,7 +1633,7 @@ var zigAnalysis;
 
                                   if (isVarArgs && i === fnObj.params.length - 1) {
                                       payloadHtml += '...';
-                                  } 
+                                  }
                                   else if ("typeOf" in value) {
                                     if (opts.wantHtml) {
                                       payloadHtml += '    ';
@@ -1626,7 +1645,7 @@ var zigAnalysis;
                                       payloadHtml += exprName(value, opts);
                                     }
 
-                                  } 
+                                  }
                                   else if ("typeOf_peer" in value) {
                                     if (opts.wantHtml) {
                                       payloadHtml += '';
@@ -1638,7 +1657,7 @@ var zigAnalysis;
                                       payloadHtml += exprName(value, opts);
                                     }
 
-                                  } 
+                                  }
                                   else if ("declRef" in value) {
                                     if (opts.wantHtml) {
                                       payloadHtml += '';
@@ -1650,7 +1669,7 @@ var zigAnalysis;
                                       payloadHtml += exprName(value, opts);
                                     }
 
-                                  } 
+                                  }
                                   else if ("call" in value) {
                                     if (opts.wantHtml) {
                                       payloadHtml += '';
@@ -1661,7 +1680,7 @@ var zigAnalysis;
                                     } else {
                                       payloadHtml += exprName(value, opts);
                                     }
-                                  } 
+                                  }
                                   else if ("refPath" in value) {
                                     if (opts.wantHtml) {
                                       payloadHtml += '';
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 44234d31db..9ff2010bf6 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -476,8 +476,9 @@ const DocData = struct {
         },
         Fn: struct {
             name: []const u8,
-            src: ?usize = null, // index into astNodes
+            src: ?usize = null, // index into `astNodes`
             ret: Expr,
+            generic_ret: ?Expr = null,
             params: ?[]Expr = null, // (use src->fields to find names)
             lib_name: []const u8 = "",
             is_var_args: bool = false,
@@ -522,7 +523,6 @@ const DocData = struct {
                 .ComptimeFloat => |v| try printTypeBody(v, options, w),
                 .Null => |v| try printTypeBody(v, options, w),
                 .Optional => |v| try printTypeBody(v, options, w),
-
                 .Struct => |v| try printTypeBody(v, options, w),
                 .Fn => |v| try printTypeBody(v, options, w),
                 .Union => |v| try printTypeBody(v, options, w),
@@ -886,6 +886,10 @@ fn walkInstruction(
             );
             return self.cteTodo(@tagName(tags[inst_index]));
         },
+        .ret_node => {
+            const un_node = data[inst_index].un_node;
+            return self.walkRef(file, parent_scope, un_node.operand, false);
+        },
         .closure_get => {
             const inst_node = data[inst_index].inst_node;
             return try self.walkInstruction(file, parent_scope, inst_node.inst, need_type);
@@ -3882,7 +3886,20 @@ fn analyzeFunctionExtended(
     }
 
     self.types.items[type_slot_index] = .{
-        .Fn = .{ .name = "todo_name func", .src = self_ast_node_index, .params = param_type_refs.items, .ret = ret_type_ref.expr, .is_extern = extra.data.bits.is_extern, .has_cc = extra.data.bits.has_cc, .has_align = extra.data.bits.has_align, .has_lib_name = extra.data.bits.has_lib_name, .lib_name = lib_name, .is_inferred_error = extra.data.bits.is_inferred_error, .cc = cc_index, .@"align" = align_index },
+        .Fn = .{
+            .name = "todo_name func",
+            .src = self_ast_node_index,
+            .params = param_type_refs.items,
+            .ret = ret_type_ref.expr,
+            .is_extern = extra.data.bits.is_extern,
+            .has_cc = extra.data.bits.has_cc,
+            .has_align = extra.data.bits.has_align,
+            .has_lib_name = extra.data.bits.has_lib_name,
+            .lib_name = lib_name,
+            .is_inferred_error = extra.data.bits.is_inferred_error,
+            .cc = cc_index,
+            .@"align" = align_index,
+        },
     };
 
     return DocData.WalkResult{
@@ -3974,6 +3991,21 @@ fn analyzeFunction(
         break :blk wr;
     };
 
+    // TODO: a complete version of this will probably need a scope
+    //       in order to evaluate correctly closures around funcion
+    //       parameters etc.
+    const generic_ret: ?DocData.Expr = switch (ret_type_ref.expr) {
+        .type => |t| if (t == @enumToInt(Ref.type_type))
+            try self.getGenericReturnType(
+                file,
+                scope,
+                fn_info.body[fn_info.body.len - 1],
+            )
+        else
+            null,
+        else => null,
+    };
+
     self.ast_nodes.items[self_ast_node_index].fields = param_ast_indexes.items;
     self.types.items[type_slot_index] = .{
         .Fn = .{
@@ -3981,6 +4013,7 @@ fn analyzeFunction(
             .src = self_ast_node_index,
             .params = param_type_refs.items,
             .ret = ret_type_ref.expr,
+            .generic_ret = generic_ret,
         },
     };
 
@@ -3990,6 +4023,16 @@ fn analyzeFunction(
     };
 }
 
+fn getGenericReturnType(
+    self: *Autodoc,
+    file: *File,
+    scope: *Scope,
+    body_end: usize,
+) !DocData.Expr {
+    const wr = try self.walkInstruction(file, scope, body_end, false);
+    return wr.expr;
+}
+
 fn collectUnionFieldInfo(
     self: *Autodoc,
     file: *File,

From d858f261396fa6b9b3097b5b4d377f6465ec5909 Mon Sep 17 00:00:00 2001
From: Loris Cro 
Date: Tue, 31 May 2022 18:15:16 +0200
Subject: [PATCH 097/137] autodoc: fixes to generic fn support plus linking
 support

---
 lib/docs/main.js | 33 +++++++++++++++++++++++++--------
 src/Autodoc.zig  | 40 ++++++++++++++++++++++++++++++++--------
 2 files changed, 57 insertions(+), 16 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index d37dea5200..f9d5f0383b 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -482,13 +482,13 @@ var zigAnalysis;
                 continue;
             }
 
-//            if ("as" in value.expr) {
-//                value = {
-//                  typeRef: zigAnalysis.exprs[value.expr.as.typeRefArg],
-//                  expr: zigAnalysis.exprs[value.expr.as.exprArg],
-//                };
-//                continue;
-//            }
+            if ("as" in value.expr) {
+                value = {
+                  typeRef: zigAnalysis.exprs[value.expr.as.typeRefArg],
+                  expr: zigAnalysis.exprs[value.expr.as.exprArg],
+                };
+                continue;
+            }
 
             return value;
 
@@ -1355,7 +1355,7 @@ var zigAnalysis;
           }
 
           case "this":{
-            return "this";
+            return "@This()";
           }
 
           case "type": {
@@ -2333,6 +2333,23 @@ var zigAnalysis;
     * @param {string} childName
     */
     function findSubDecl(parentType, childName) {
+        {
+            // Generic functions
+            if ("value" in parentType) {
+                const rv = resolveValue(parentType.value);
+                if ("type" in rv.expr) {
+                    const t = zigAnalysis.types[rv.expr.type];
+                    if (t.kind == typeKinds.Fn && t.generic_ret != null) {
+                        const rgr = resolveValue({expr: t.generic_ret});
+                        if ("type" in rgr.expr) {
+                            parentType = zigAnalysis.types[rgr.expr.type];
+                        }
+                    }
+                }
+            }
+        }
+
+
         if (!parentType.pubDecls) return null;
         for (let i = 0; i < parentType.pubDecls.length; i += 1) {
             let declIndex = parentType.pubDecls[i];
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 9ff2010bf6..f9b15b0c2d 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -3885,12 +3885,32 @@ fn analyzeFunctionExtended(
         _ = try self.walkRef(file, scope, align_ref, false);
     }
 
+    // TODO: a complete version of this will probably need a scope
+    //       in order to evaluate correctly closures around funcion
+    //       parameters etc.
+    const generic_ret: ?DocData.Expr = switch (ret_type_ref.expr) {
+        .type => |t| blk: {
+            if (fn_info.body.len == 0) break :blk null;
+            if (t == @enumToInt(Ref.type_type)) {
+                break :blk try self.getGenericReturnType(
+                    file,
+                    scope,
+                    fn_info.body[fn_info.body.len - 1],
+                );
+            } else {
+                break :blk null;
+            }
+        },
+        else => null,
+    };
+
     self.types.items[type_slot_index] = .{
         .Fn = .{
             .name = "todo_name func",
             .src = self_ast_node_index,
             .params = param_type_refs.items,
             .ret = ret_type_ref.expr,
+            .generic_ret = generic_ret,
             .is_extern = extra.data.bits.is_extern,
             .has_cc = extra.data.bits.has_cc,
             .has_align = extra.data.bits.has_align,
@@ -3995,14 +4015,18 @@ fn analyzeFunction(
     //       in order to evaluate correctly closures around funcion
     //       parameters etc.
     const generic_ret: ?DocData.Expr = switch (ret_type_ref.expr) {
-        .type => |t| if (t == @enumToInt(Ref.type_type))
-            try self.getGenericReturnType(
-                file,
-                scope,
-                fn_info.body[fn_info.body.len - 1],
-            )
-        else
-            null,
+        .type => |t| blk: {
+            if (fn_info.body.len == 0) break :blk null;
+            if (t == @enumToInt(Ref.type_type)) {
+                break :blk try self.getGenericReturnType(
+                    file,
+                    scope,
+                    fn_info.body[fn_info.body.len - 1],
+                );
+            } else {
+                break :blk null;
+            }
+        },
         else => null,
     };
 

From a0ec87be717094b080a98595cfd4ceb0aec38cdf Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Tue, 31 May 2022 19:48:00 -0300
Subject: [PATCH 098/137] add: merge_error_sets and @alignOf() need a checkin
 to confirm it's fully work

---
 lib/docs/main.js |  31 +++++++++-
 src/Autodoc.zig  | 151 ++++++++++++++++++++++++++++++++++++++---------
 2 files changed, 150 insertions(+), 32 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index f9d5f0383b..3c84b56aea 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1093,16 +1093,16 @@ var zigAnalysis;
               console.log(caseIndex);
               console.log(item);
               if (item['enumLiteral']) {
-                payloadHtml += "   " + " ." + exprName(item, opts) + " = " + "
    ";
+                payloadHtml += "   " + " ." + exprName(item, opts) + " => {} " + "
    ";
                 continue;
               }
-              payloadHtml += "    " + exprName(item, opts) + " = " + "
    ";
+              payloadHtml += "    " + exprName(item, opts) + " => {} " + "
    ";
             }
               if (expr.switchOp.else_index !== 0) {
                 const else_index = expr.switchOp.else_index;
                 const item = zigAnalysis.exprs[else_index];
                 console.log(item);
-                payloadHtml += "    " + "else" + " = " + "
    ";
+                payloadHtml += "    " + "else" + " => {} " + "
    ";
               }
               payloadHtml += "}";
             return payloadHtml;
@@ -1239,6 +1239,13 @@ var zigAnalysis;
             }
             return print_lhs + " " + operator + " " + print_rhs;
 
+          }
+          case "errorSets": {
+            const errUnionObj = zigAnalysis.types[expr.errorSets];
+            let lhs = exprName(errUnionObj.lhs, opts);
+            let rhs = exprName(errUnionObj.rhs, opts);
+            return lhs + " || " + rhs;
+
           }
           case "errorUnion": {
             const errUnionObj = zigAnalysis.types[expr.errorUnion];
@@ -1281,6 +1288,11 @@ var zigAnalysis;
             return payloadHtml;
 
           }
+          case "alignOf": {
+            const alignRefArg = zigAnalysis.exprs[expr.alignOf];
+            let payloadHtml = "@alignOf(" + exprName(alignRefArg, {wantHtml: true, wantLink:true}) + ")";
+            return payloadHtml;
+          }
           case "typeOf": {
             const typeRefArg = zigAnalysis.exprs[expr.typeOf];
             let payloadHtml = "@TypeOf(" + exprName(typeRefArg, {wantHtml: true, wantLink:true}) + ")";
@@ -1634,6 +1646,18 @@ var zigAnalysis;
                                   if (isVarArgs && i === fnObj.params.length - 1) {
                                       payloadHtml += '...';
                                   }
+                                  else if ("alignOf" in value) {
+                                    if (opts.wantHtml) {
+                                      payloadHtml += '    ';
+                                      payloadHtml +=
+                                        ''
+                                        + exprName(value, opts) + '';
+                                      payloadHtml += '';
+                                    } else {
+                                      payloadHtml += exprName(value, opts);
+                                    }
+
+                                  }
                                   else if ("typeOf" in value) {
                                     if (opts.wantHtml) {
                                       payloadHtml += '';
@@ -1728,6 +1752,7 @@ var zigAnalysis;
                     }
 
                       if (fnObj.is_inferred_error) {
+                         console.log(fnObj)
                           payloadHtml += "!";
                       }
                       if (fnObj.ret != null) {
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index f9b15b0c2d..9f24497a48 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -657,6 +657,7 @@ const DocData = struct {
         array: []usize, // index in `exprs`
         call: usize, // index in `calls`
         enumLiteral: []const u8, // direct value
+        alignOf: usize, // index in `exprs`
         typeOf: usize, // index in `exprs`
         typeOf_peer: []usize,
         errorUnion: usize, // index in `exprs`
@@ -665,6 +666,7 @@ const DocData = struct {
         bitSizeOf: usize, // index in `exprs`
         enumToInt: usize, // index in `exprs`
         compileError: []const u8,
+        errorSets: usize,
         string: []const u8, // direct value
         switchIndex: usize, // index in `exprs`
         switchOp: SwitchOp,
@@ -693,9 +695,6 @@ const DocData = struct {
         const SwitchOp = struct {
             cases: []usize,
             else_index: ?usize,
-            // body_cases: ?[]usize,
-
-            // const Case = struct { lhs: Expr, rhs: Expr };
         };
         const As = struct {
             typeRefArg: ?usize, // index in `exprs`
@@ -722,7 +721,7 @@ const DocData = struct {
                         \\{{ "{s}":{{}} }}
                     , .{@tagName(self)});
                 },
-                .type, .comptimeExpr, .call, .this, .declRef, .typeOf, .errorUnion => |v| {
+                .type, .comptimeExpr, .call, .this, .declRef, .typeOf, .errorUnion, .errorSets, .alignOf => |v| {
                     try w.print(
                         \\{{ "{s}":{} }}
                     , .{ @tagName(self), v });
@@ -1792,6 +1791,33 @@ fn walkInstruction(
                 .expr = .{ .errorUnion = type_slot_index },
             };
         },
+        .merge_error_sets => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+            const type_slot_index = self.types.items.len;
+            try self.types.append(self.arena, .{ .ErrorUnion = .{
+                .lhs = lhs.expr,
+                .rhs = rhs.expr,
+            } });
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .errorSets = type_slot_index },
+            };
+        },
         .elem_type => {
             const un_node = data[inst_index].un_node;
 
@@ -2228,15 +2254,17 @@ fn walkInstruction(
             };
         },
         .switch_block => {
+            // WIP
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.SwitchBlock, pl_node.payload_index);
             const array_data = try self.arena.alloc(usize, extra.data.bits.scalar_cases_len);
             var extra_index = extra.end;
 
-            const sep = "=" ** 200;
-            std.debug.print("{s}\n", .{sep});
-            std.debug.print("pl_node = {any}\n", .{pl_node});
-            std.debug.print("extra = {any}\n", .{extra});
+            // const sep = "=" ** 200;
+            // std.debug.print("{s}\n", .{sep});
+            // std.debug.print("pl_node = {any}\n", .{pl_node});
+            // std.debug.print("extra = {any}\n", .{extra});
+            // std.debug.print("{s}\n", .{sep});
 
             const multi_cases_len = if (extra.data.bits.has_multi_cases) blk: {
                 const multi_cases_len = file.zir.extra[extra_index];
@@ -2251,12 +2279,12 @@ fn walkInstruction(
                 extra_index += 1;
                 const body = file.zir.extra[extra_index..][0..body_len];
                 extra_index += body.len;
-                for (body) |body_member| {
+                for (body) |_| {
                     const item_ref = @intToEnum(Ref, file.zir.extra[extra_index]);
                     const item = try self.walkRef(file, parent_scope, item_ref, false);
-                    std.debug.print("prong item_ref = {any}\n", .{item_ref});
-                    std.debug.print("prong item = {any}\n", .{item});
-                    std.debug.print("body member = {any}\n", .{body_member});
+                    // std.debug.print("prong item_ref = {any}\n", .{item_ref});
+                    // std.debug.print("prong item = {any}\n", .{item});
+                    // std.debug.print("body member = {any}\n", .{body_member});
                     const item_index = self.exprs.items.len;
                     try self.exprs.append(self.arena, item.expr);
                     else_index = item_index;
@@ -2279,15 +2307,16 @@ fn walkInstruction(
                     array_data[scalar_i] = item.expr.as.exprArg;
 
                     const body_ref = @intToEnum(Ref, file.zir.extra[extra_index]);
-                    const body_item = try self.walkRef(file, parent_scope, item_ref, false);
+                    const body_item = try self.walkRef(file, parent_scope, body_ref, false);
+                    _ = body_item;
 
                     array_data[scalar_i] = item.expr.as.exprArg;
-                    std.debug.print("{s}\n", .{sep});
-                    std.debug.print("body item_ref = {any}\n", .{item_ref});
-                    std.debug.print("body item = {any}\n", .{item});
-                    std.debug.print("body_len scalar cases = {any}\n", .{body_ref});
-                    std.debug.print("body scalar cases = {any}\n", .{body_item});
-                    std.debug.print("{s}\n", .{sep});
+                    // std.debug.print("{s}\n", .{sep});
+                    // std.debug.print("body item_ref = {any}\n", .{item_ref});
+                    // std.debug.print("body item = {any}\n", .{item});
+                    // std.debug.print("body_len scalar cases = {any}\n", .{body_ref});
+                    // std.debug.print("body scalar cases = {any}\n", .{body_item});
+                    // std.debug.print("{s}\n", .{sep});
                 }
             }
             {
@@ -2311,14 +2340,15 @@ fn walkInstruction(
 
                     const body = file.zir.extra[extra_index..][0..body_len];
                     extra_index += body_len;
+                    _ = body;
 
-                    std.debug.print("body multi_i = {any}\n", .{body});
-                    std.debug.print("items = {any}\n", .{items});
+                    // std.debug.print("body multi_i = {any}\n", .{body});
+                    // std.debug.print("items = {any}\n", .{items});
                 }
             }
 
             // std.debug.print("multi_cases_len = {}\n", .{multi_cases_len});
-            std.debug.print("{s}\n", .{sep});
+            // std.debug.print("{s}\n", .{sep});
 
             const switch_index = self.exprs.items.len;
             try self.exprs.append(self.arena, .{ .switchOp = .{ .cases = array_data, .else_index = else_index } });
@@ -2368,6 +2398,26 @@ fn walkInstruction(
                 .expr = .{ .typeOf = operand_index },
             };
         },
+        .align_of => {
+            // WIP
+            // not fully working
+            // @alignOf() with some pointer type it's not even called in js
+            // @alignOf([*]u8) are being rendered as [*]u8
+            const un_node = data[inst_index].un_node;
+            const operand = try self.walkRef(
+                file,
+                parent_scope,
+                un_node.operand,
+                need_type,
+            );
+            const operand_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, operand.expr);
+
+            return DocData.WalkResult{
+                .typeRef = operand.typeRef,
+                .expr = .{ .alignOf = operand_index },
+            };
+        },
         .typeof_builtin => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Block, pl_node.payload_index);
@@ -2388,6 +2438,31 @@ fn walkInstruction(
                 .expr = .{ .typeOf = operand_index },
             };
         },
+        .typeof_log2_int_type => {
+            // @check
+            const un_node = data[inst_index].un_node;
+            const operand = try self.walkRef(
+                file,
+                parent_scope,
+                un_node.operand,
+                need_type,
+            );
+
+            // WIP
+            // const sep = "=" ** 200;
+            // std.debug.print("{s}\n", .{sep});
+            // std.debug.print("un_node = {any}\n", .{un_node});
+            // std.debug.print("operand = {any}\n", .{operand});
+            // std.debug.print("{s}\n", .{sep});
+
+            const operand_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, operand.expr);
+
+            return DocData.WalkResult{
+                .typeRef = operand.typeRef,
+                .expr = .{ .typeOf = operand_index },
+            };
+        },
         .type_info => {
             // @check
             const un_node = data[inst_index].un_node;
@@ -2536,6 +2611,23 @@ fn walkInstruction(
                 .expr = .{ .type = self.types.items.len - 1 },
             };
         },
+        .float128 => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Float128, pl_node.payload_index);
+            _ = extra;
+            // const sep = "=" ** 200;
+            // std.debug.print("{s}\n", .{sep});
+            // std.debug.print("pl_node = {any}\n", .{pl_node});
+            // std.debug.print("extra = {any}\n", .{extra});
+            // std.debug.print("{s}\n", .{sep});
+            // printWithContext(
+            //     file,
+            //     inst_index,
+            //     "TODO: implement `{s}` for walkInstruction\n\n",
+            //     .{@tagName(tags[inst_index])},
+            // );
+            return self.cteTodo(@tagName(tags[inst_index]));
+        },
         .block => {
             const res = DocData.WalkResult{ .expr = .{
                 .comptimeExpr = self.comptime_exprs.items.len,
@@ -3746,14 +3838,15 @@ fn tryResolveRefPath(
                     }
 
                     // if we got here, our search failed
-                    printWithContext(
-                        file,
-                        inst_index,
-                        "failed to match `{s}` in struct",
-                        .{child_string},
-                    );
+                    // printWithContext(
+                    //     file,
+                    //     inst_index,
+                    //     "failed to match `{s}` in struct",
+                    //     .{child_string},
+                    // );
                     // path[i + 1] = (try self.cteTodo("match failure")).expr;
-                    // this are working, check c.zig
+                    //
+                    // that's working
                     path[i + 1] = (try self.cteTodo(child_string)).expr;
                     continue :outer;
                 },

From b9fa91002eeec00312b55a1412476deb84a627c3 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Wed, 1 Jun 2022 01:24:29 -0300
Subject: [PATCH 099/137] add: builtins functions

---
 lib/docs/main.js | 211 +++++++++++++++++++++++++++-
 src/Autodoc.zig  | 347 ++++++++++++++++++++++++++++++++++++-----------
 2 files changed, 473 insertions(+), 85 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 3c84b56aea..f8561f86a5 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1085,6 +1085,9 @@ var zigAnalysis;
             let literal = expr.enumLiteral;
             return literal;
           }
+          case "void": {
+            return "VOID WIP";
+          }
           case "switchOp":{
             let payloadHtml = "switch() {
    ";
             for (let i = 0; i < expr.switchOp.cases.length; i++) {
@@ -1115,13 +1118,12 @@ var zigAnalysis;
             // const fieldRef = zigAnalysis.decls[expr.fieldRef.index];
             // const struct_name = zigAnalysis.decls[expr.struct[0].val.typeRef.refPath[0].declRef].name;
             console.log(expr)
-            console.log(fieldRef)
+            // console.log(fieldRef)
             // return "@enumToInt(" + exprName(enumToInt, opts) + ")";
             // return exprName(fieldRef,opts);
             return "WIP"
           }
           case "enumToInt" : {
-            console.log(expr);
             const enumToInt = zigAnalysis.exprs[expr.enumToInt];
             return "@enumToInt(" + exprName(enumToInt, opts) + ")";
           }
@@ -1133,6 +1135,187 @@ var zigAnalysis;
             const sizeOf = zigAnalysis.exprs[expr.sizeOf];
             return "@sizeOf(" + exprName(sizeOf, opts) + ")";
           }
+          case "builtinIndex" : {
+            const builtinIndex = zigAnalysis.exprs[expr.builtinIndex];
+            return exprName(builtinIndex, opts);
+          }
+          case "builtin": {
+            const param_expr = zigAnalysis.exprs[expr.builtin.param];
+            let param = exprName(param_expr, opts);
+
+            let payloadHtml = "@";
+            switch (expr.builtin.name) {
+
+              case "align_of": {
+                payloadHtml += "alignOf";
+                break;
+              }
+              case "bool_to_int": {
+                payloadHtml += "boolToInt";
+                break;
+              }
+              case "embed_file": {
+                payloadHtml += "embedFile";
+                break;
+              }
+              case "error_name": {
+                payloadHtml += "errorName";
+                break;
+              }
+              case "panic": {
+                payloadHtml += "panic";
+                break;
+              }
+              case "set_cold": {
+                payloadHtml += "setCold";
+                break;
+              }
+              case "set_runtime_safety": {
+                payloadHtml += "setRuntimeSafety";
+                break;
+              }
+              case "sqrt": {
+                payloadHtml += "sqrt";
+                break;
+              }
+              case "sin": {
+                payloadHtml += "sin";
+                break;
+              }
+              case "cos": {
+                payloadHtml += "cos";
+                break;
+              }
+              case "tan": {
+                payloadHtml += "tan";
+                break;
+              }
+              case "exp": {
+                payloadHtml += "exp";
+                break;
+              }
+              case "exp2": {
+                payloadHtml += "exp2";
+                break;
+              }
+              case "log": {
+                payloadHtml += "log";
+                break;
+              }
+              case "log2": {
+                payloadHtml += "log2";
+                break;
+              }
+              case "log10": {
+                payloadHtml += "log10";
+                break;
+              }
+              case "fabs": {
+                payloadHtml += "fabs";
+                break;
+              }
+              case "floor": {
+                payloadHtml += "floor";
+                break;
+              }
+              case "ceil": {
+                payloadHtml += "ceil";
+                break;
+              }
+              case "trunc": {
+                payloadHtml += "trunc";
+                break;
+              }
+              case "round": {
+                payloadHtml += "round";
+                break;
+              }
+              case "tag_name": {
+                payloadHtml += "tagName";
+                break;
+              }
+              case "reify": {
+                payloadHtml += "Type";
+                break;
+              }
+              case "type_name": {
+                payloadHtml += "typeName";
+                break;
+              }
+              case "frame_type": {
+                payloadHtml += "Frame";
+                break;
+              }
+              case "frame_size": {
+                payloadHtml += "frameSize";
+                break;
+              }
+              default: console.log("builtin function not handled yet or doesn't exist!");
+            };
+            return payloadHtml + "(" + param + ")";
+
+          }
+          case "builtinBinIndex" : {
+            const builtinBinIndex = zigAnalysis.exprs[expr.builtinBinIndex];
+            return exprName(builtinBinIndex, opts);
+          }
+          case "builtinBin": {
+            const lhsOp = zigAnalysis.exprs[expr.builtinBin.lhs];
+            const rhsOp = zigAnalysis.exprs[expr.builtinBin.rhs];
+            let lhs = exprName(lhsOp, opts);
+            let rhs = exprName(rhsOp, opts);
+
+            let payloadHtml = "@";
+            switch (expr.builtinBin.name) {
+              case "float_to_int": {
+                payloadHtml += "floatToInt";
+                break;
+              }
+              case "int_to_float": {
+                payloadHtml += "intToFloat";
+                break;
+              }
+              case "int_to_ptr": {
+                payloadHtml += "intToPtr";
+                break;
+              }
+              case "int_to_enum": {
+                payloadHtml += "intToEnum";
+                break;
+              }
+              case "float_cast": {
+                payloadHtml += "floatCast";
+                break;
+              }
+              case "int_cast": {
+                payloadHtml += "intCast";
+                break;
+              }
+              case "ptr_cast": {
+                payloadHtml += "ptrCast";
+                break;
+              }
+              case "truncate": {
+                payloadHtml += "truncate";
+                break;
+              }
+              case "align_cast": {
+                payloadHtml += "alignCast";
+                break;
+              }
+              case "has_decl": {
+                payloadHtml += "hasDecl";
+                break;
+              }
+              case "has_field": {
+                payloadHtml += "hasField";
+                break;
+              }
+              default: console.log("builtin function not handled yet or doesn't exist!");
+            };
+            return payloadHtml + "(" + lhs + ", " + rhs + ")";
+
+          }
           case "binOpIndex" : {
             const binOpIndex = zigAnalysis.exprs[expr.binOpIndex];
             return exprName(binOpIndex, opts);
@@ -1146,9 +1329,6 @@ var zigAnalysis;
             let print_lhs = "";
             let print_rhs = "";
 
-            console.log(lhsOp)
-            console.log(rhsOp)
-
             if (lhsOp['binOpIndex']) {
               print_lhs = "(" + lhs + ")";
             } else {
@@ -1229,6 +1409,21 @@ var zigAnalysis;
               case 11 : {
                 return "@alignCast(" + print_lhs + ", " + print_rhs + ")";
               }
+              case 12 : {
+                operator += "&";
+                break;
+              }
+              case 13 : {
+                operator += "++";
+                break;
+              }
+              case 14 : {
+                operator += "**";
+                break;
+              }
+              case 15 : {
+                return "@Vector(" + print_lhs + ", " + print_rhs + ")";
+              }
               default: console.log("operator not handled yet or doesn't exist!");
             };
             if (expr.binOp.wrap) {
@@ -1723,7 +1918,11 @@ var zigAnalysis;
                                         linkFnNameDecl: opts.linkFnNameDecl,
                                       });
                                       payloadHtml += '' + escapeHtml(name) + '';
-                                  } else if ("comptimeExpr" in value) {
+                                  } else if ("binOpIndex" in value) {
+                                    payloadHtml += exprName(value, opts);
+                                    console.log(value);
+                                    console.log(payloadHtml);
+                                  }else if ("comptimeExpr" in value) {
                                       let comptimeExpr = zigAnalysis.comptimeExprs[value.comptimeExpr].code;
                                       if (opts.wantHtml) {
                                         payloadHtml += '' + comptimeExpr + '';
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 9f24497a48..5077b7df81 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -668,6 +668,10 @@ const DocData = struct {
         compileError: []const u8,
         errorSets: usize,
         string: []const u8, // direct value
+        builtin: Builtin,
+        builtinIndex: usize,
+        builtinBin: BuiltinBin,
+        builtinBinIndex: usize,
         switchIndex: usize, // index in `exprs`
         switchOp: SwitchOp,
         // Index a `type` like struct with expressions
@@ -682,7 +686,7 @@ const DocData = struct {
             rhs: usize, // index in `exprs`
             // opKind
             // Identify the operator in js
-            // 0: add, 1: sub, 2: mul, 3: div, 4: mod, 5: rem, 6: rem_mod, 7: shl, 8: shr, 9: bitcast, 10: bit_or, 11: align_cast
+            // 0: add, 1: sub, 2: mul, 3: div, 4: mod, 5: rem, 6: rem_mod, 7: shl, 8: shr, 9: bitcast, 10: bit_or, 11: align_cast, 12: bit_and, 13: array_cat, 14: array_mul, 15: vector
             // Others binOp are not handled yet
             opKind: usize = 0,
             // flags to operations
@@ -696,6 +700,15 @@ const DocData = struct {
             cases: []usize,
             else_index: ?usize,
         };
+        const BuiltinBin = struct {
+            name: []const u8 = "", // fn name
+            lhs: usize, // index in `exprs`
+            rhs: usize, // index in `exprs`
+        };
+        const Builtin = struct {
+            name: []const u8 = "", // fn name
+            param: usize, // index in `exprs`
+        };
         const As = struct {
             typeRefArg: ?usize, // index in `exprs`
             exprArg: usize, // index in `exprs`
@@ -800,6 +813,26 @@ const DocData = struct {
                     options,
                     w,
                 ),
+                .builtin => |v| try std.json.stringify(
+                    struct { builtin: Builtin }{ .builtin = v },
+                    options,
+                    w,
+                ),
+                .builtinIndex => |v| try std.json.stringify(
+                    struct { builtinIndex: usize }{ .builtinIndex = v },
+                    options,
+                    w,
+                ),
+                .builtinBin => |v| try std.json.stringify(
+                    struct { builtinBin: BuiltinBin }{ .builtinBin = v },
+                    options,
+                    w,
+                ),
+                .builtinBinIndex => |v| try std.json.stringify(
+                    struct { builtinBinIndex: usize }{ .builtinBinIndex = v },
+                    options,
+                    w,
+                ),
                 .typeOf_peer => |v| try std.json.stringify(
                     struct { typeOf_peer: []usize }{ .typeOf_peer = v },
                     options,
@@ -1041,37 +1074,38 @@ fn walkInstruction(
                 .expr = .{ .binOpIndex = binop_index },
             };
         },
-        .align_cast => {
-            const pl_node = data[inst_index].pl_node;
-            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
-
-            const binop_index = self.exprs.items.len;
-            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
-
-            var lhs: DocData.WalkResult = try self.walkRef(
-                file,
-                parent_scope,
-                extra.data.lhs,
-                false,
-            );
-            var rhs: DocData.WalkResult = try self.walkRef(
-                file,
-                parent_scope,
-                extra.data.rhs,
-                false,
-            );
-
-            const lhs_index = self.exprs.items.len;
-            try self.exprs.append(self.arena, lhs.expr);
-            const rhs_index = self.exprs.items.len;
-            try self.exprs.append(self.arena, rhs.expr);
-            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 11 } };
-
-            return DocData.WalkResult{
-                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
-                .expr = .{ .binOpIndex = binop_index },
-            };
-        },
+        // implementing in builtinBin @check if it's ok to delete it
+        // .align_cast => {
+        //     const pl_node = data[inst_index].pl_node;
+        //     const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+        //
+        //     const binop_index = self.exprs.items.len;
+        //     try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+        //
+        //     var lhs: DocData.WalkResult = try self.walkRef(
+        //         file,
+        //         parent_scope,
+        //         extra.data.lhs,
+        //         false,
+        //     );
+        //     var rhs: DocData.WalkResult = try self.walkRef(
+        //         file,
+        //         parent_scope,
+        //         extra.data.rhs,
+        //         false,
+        //     );
+        //
+        //     const lhs_index = self.exprs.items.len;
+        //     try self.exprs.append(self.arena, lhs.expr);
+        //     const rhs_index = self.exprs.items.len;
+        //     try self.exprs.append(self.arena, rhs.expr);
+        //     self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 11 } };
+        //
+        //     return DocData.WalkResult{
+        //         .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+        //         .expr = .{ .binOpIndex = binop_index },
+        //     };
+        // },
         .bit_or => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
@@ -1103,6 +1137,37 @@ fn walkInstruction(
                 .expr = .{ .binOpIndex = binop_index },
             };
         },
+        .bit_and => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 12 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
         .add => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
@@ -1763,6 +1828,175 @@ fn walkInstruction(
             };
         },
 
+        // throwing this TODO
+        // TODO: handle `Array` in tryResolveDeclPath.type
+        // .array_cat => {
+        //     const pl_node = data[inst_index].pl_node;
+        //     const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+        //
+        //     const binop_index = self.exprs.items.len;
+        //     try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+        //
+        //     var lhs: DocData.WalkResult = try self.walkRef(
+        //         file,
+        //         parent_scope,
+        //         extra.data.lhs,
+        //         false,
+        //     );
+        //     var rhs: DocData.WalkResult = try self.walkRef(
+        //         file,
+        //         parent_scope,
+        //         extra.data.rhs,
+        //         false,
+        //     );
+        //
+        //     const lhs_index = self.exprs.items.len;
+        //     try self.exprs.append(self.arena, lhs.expr);
+        //     const rhs_index = self.exprs.items.len;
+        //     try self.exprs.append(self.arena, rhs.expr);
+        //     self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 13 } };
+        //
+        //     return DocData.WalkResult{
+        //         .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+        //         .expr = .{ .binOpIndex = binop_index },
+        //     };
+        // },
+        // .array_mul => {
+        //     const pl_node = data[inst_index].pl_node;
+        //     const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+        //
+        //     const binop_index = self.exprs.items.len;
+        //     try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+        //
+        //     var lhs: DocData.WalkResult = try self.walkRef(
+        //         file,
+        //         parent_scope,
+        //         extra.data.lhs,
+        //         false,
+        //     );
+        //     var rhs: DocData.WalkResult = try self.walkRef(
+        //         file,
+        //         parent_scope,
+        //         extra.data.rhs,
+        //         false,
+        //     );
+        //
+        //     const lhs_index = self.exprs.items.len;
+        //     try self.exprs.append(self.arena, lhs.expr);
+        //     const rhs_index = self.exprs.items.len;
+        //     try self.exprs.append(self.arena, rhs.expr);
+        //     self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 14 } };
+        //
+        //     return DocData.WalkResult{
+        //         .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+        //         .expr = .{ .binOpIndex = binop_index },
+        //     };
+        // },
+        .vector_type => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 15 } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .binOpIndex = binop_index },
+            };
+        },
+
+        .align_of,
+        .bool_to_int,
+        .embed_file,
+        .error_name,
+        .panic,
+        .set_cold, // @check
+        .set_runtime_safety, // @check
+        .sqrt,
+        .sin,
+        .cos,
+        .tan,
+        .exp,
+        .exp2,
+        .log,
+        .log2,
+        .log10,
+        .fabs,
+        .floor,
+        .ceil,
+        .trunc,
+        .round,
+        .tag_name,
+        .reify,
+        .type_name,
+        .frame_type,
+        .frame_size,
+        => {
+            const un_node = data[inst_index].un_node;
+            const bin_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .builtin = .{ .param = 0 } });
+            const param = try self.walkRef(file, parent_scope, un_node.operand, false);
+
+            const param_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, param.expr);
+
+            self.exprs.items[bin_index] = .{ .builtin = .{ .name = @tagName(tags[inst_index]), .param = param_index } };
+
+            return DocData.WalkResult{
+                .typeRef = param.typeRef,
+                .expr = .{ .builtinIndex = bin_index },
+            };
+        },
+        .float_to_int, .int_to_float, .int_to_ptr, .int_to_enum, .float_cast, .int_cast, .ptr_cast, .truncate, .align_cast, .has_decl, .has_field => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
+
+            const binop_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .builtinBin = .{ .lhs = 0, .rhs = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var rhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.rhs,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const rhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, rhs.expr);
+            self.exprs.items[binop_index] = .{ .builtinBin = .{ .name = @tagName(tags[inst_index]), .lhs = lhs_index, .rhs = rhs_index } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .builtinBinIndex = binop_index },
+            };
+        },
         .error_union_type => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
@@ -2398,26 +2632,6 @@ fn walkInstruction(
                 .expr = .{ .typeOf = operand_index },
             };
         },
-        .align_of => {
-            // WIP
-            // not fully working
-            // @alignOf() with some pointer type it's not even called in js
-            // @alignOf([*]u8) are being rendered as [*]u8
-            const un_node = data[inst_index].un_node;
-            const operand = try self.walkRef(
-                file,
-                parent_scope,
-                un_node.operand,
-                need_type,
-            );
-            const operand_index = self.exprs.items.len;
-            try self.exprs.append(self.arena, operand.expr);
-
-            return DocData.WalkResult{
-                .typeRef = operand.typeRef,
-                .expr = .{ .alignOf = operand_index },
-            };
-        },
         .typeof_builtin => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Block, pl_node.payload_index);
@@ -2438,31 +2652,6 @@ fn walkInstruction(
                 .expr = .{ .typeOf = operand_index },
             };
         },
-        .typeof_log2_int_type => {
-            // @check
-            const un_node = data[inst_index].un_node;
-            const operand = try self.walkRef(
-                file,
-                parent_scope,
-                un_node.operand,
-                need_type,
-            );
-
-            // WIP
-            // const sep = "=" ** 200;
-            // std.debug.print("{s}\n", .{sep});
-            // std.debug.print("un_node = {any}\n", .{un_node});
-            // std.debug.print("operand = {any}\n", .{operand});
-            // std.debug.print("{s}\n", .{sep});
-
-            const operand_index = self.exprs.items.len;
-            try self.exprs.append(self.arena, operand.expr);
-
-            return DocData.WalkResult{
-                .typeRef = operand.typeRef,
-                .expr = .{ .typeOf = operand_index },
-            };
-        },
         .type_info => {
             // @check
             const un_node = data[inst_index].un_node;
@@ -3681,8 +3870,8 @@ fn tryResolveRefPath(
                     panicWithContext(
                         file,
                         inst_index,
-                        "TODO: handle `{s}` in tryResolveDeclPath.type\n",
-                        .{@tagName(self.types.items[t_index])},
+                        "TODO: handle `{s}` in tryResolveDeclPath.type\nInfo: {}",
+                        .{ @tagName(self.types.items[t_index]), resolved_parent },
                     );
                 },
                 .Unanalyzed => {

From 1f5df0e03401be36e68dd31f4704ebdc03141986 Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Wed, 1 Jun 2022 16:06:49 -0300
Subject: [PATCH 100/137] add: slice_start, slice_end and slice_sentinel

---
 lib/docs/main.js |  51 +++++++++++++++++-
 src/Autodoc.zig  | 138 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 188 insertions(+), 1 deletion(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index f8561f86a5..277389ddf5 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1086,7 +1086,33 @@ var zigAnalysis;
             return literal;
           }
           case "void": {
-            return "VOID WIP";
+            return "void";
+          }
+          case "slice":{
+            let payloadHtml = "";
+            const lhsExpr = zigAnalysis.exprs[expr.slice.lhs];
+            const startExpr = zigAnalysis.exprs[expr.slice.start];
+            console.log(expr)
+            let decl = exprName(lhsExpr);
+            let start = exprName(startExpr);
+            let end = "";
+            let sentinel = "";
+            if (expr.slice['end']) {
+              const endExpr = zigAnalysis.exprs[expr.slice.end];
+              let end_ = exprName(endExpr);
+              end += end_;
+            }
+            if (expr.slice['sentinel']) {
+              const sentinelExpr = zigAnalysis.exprs[expr.slice.sentinel];
+              let sentinel_ = exprName(sentinelExpr);
+              sentinel += " :" + sentinel_;
+            }
+            payloadHtml += decl + "["+ start + ".." + end + sentinel + "]";
+            return payloadHtml;
+          }
+          case "sliceIndex": {
+            const sliceIndex = zigAnalysis.exprs[expr.sliceIndex];
+            return exprName(sliceIndex, opts);
           }
           case "switchOp":{
             let payloadHtml = "switch() {
    ";
@@ -1257,6 +1283,7 @@ var zigAnalysis;
           }
           case "builtinBinIndex" : {
             const builtinBinIndex = zigAnalysis.exprs[expr.builtinBinIndex];
+            console.log(expr)
             return exprName(builtinBinIndex, opts);
           }
           case "builtinBin": {
@@ -1265,6 +1292,8 @@ var zigAnalysis;
             let lhs = exprName(lhsOp, opts);
             let rhs = exprName(rhsOp, opts);
 
+            console.log(expr);
+
             let payloadHtml = "@";
             switch (expr.builtinBin.name) {
               case "float_to_int": {
@@ -1311,6 +1340,26 @@ var zigAnalysis;
                 payloadHtml += "hasField";
                 break;
               }
+              case "clz": {
+                payloadHtml += "clz";
+                break;
+              }
+              case "ctz": {
+                payloadHtml += "ctz";
+                break;
+              }
+              case "pop_count": {
+                payloadHtml += "popCount";
+                break;
+              }
+              case "byte_swap": {
+                payloadHtml += "byteSwap";
+                break;
+              }
+              case "bit_reverse": {
+                payloadHtml += "bitReverse";
+                break;
+              }
               default: console.log("builtin function not handled yet or doesn't exist!");
             };
             return payloadHtml + "(" + lhs + ", " + rhs + ")";
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 5077b7df81..88e0354af0 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -668,6 +668,8 @@ const DocData = struct {
         compileError: []const u8,
         errorSets: usize,
         string: []const u8, // direct value
+        sliceIndex: usize,
+        slice: Slice,
         builtin: Builtin,
         builtinIndex: usize,
         builtinBin: BuiltinBin,
@@ -709,6 +711,12 @@ const DocData = struct {
             name: []const u8 = "", // fn name
             param: usize, // index in `exprs`
         };
+        const Slice = struct {
+            lhs: usize, // index in `exprs`
+            start: usize,
+            end: ?usize = null,
+            sentinel: ?usize = null, // index in `exprs`
+        };
         const As = struct {
             typeRefArg: ?usize, // index in `exprs`
             exprArg: usize, // index in `exprs`
@@ -833,6 +841,16 @@ const DocData = struct {
                     options,
                     w,
                 ),
+                .slice => |v| try std.json.stringify(
+                    struct { slice: Slice }{ .slice = v },
+                    options,
+                    w,
+                ),
+                .sliceIndex => |v| try std.json.stringify(
+                    struct { sliceIndex: usize }{ .sliceIndex = v },
+                    options,
+                    w,
+                ),
                 .typeOf_peer => |v| try std.json.stringify(
                     struct { typeOf_peer: []usize }{ .typeOf_peer = v },
                     options,
@@ -1106,6 +1124,123 @@ fn walkInstruction(
         //         .expr = .{ .binOpIndex = binop_index },
         //     };
         // },
+        .slice_start => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.SliceStart, pl_node.payload_index);
+
+            const slice_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .slice = .{ .lhs = 0, .start = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var start: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.start,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const start_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, start.expr);
+            self.exprs.items[slice_index] = .{ .slice = .{ .lhs = lhs_index, .start = start_index } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .sliceIndex = slice_index },
+            };
+        },
+        .slice_end => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.SliceEnd, pl_node.payload_index);
+
+            const slice_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .slice = .{ .lhs = 0, .start = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var start: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.start,
+                false,
+            );
+            var end: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.end,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const start_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, start.expr);
+            const end_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, end.expr);
+            self.exprs.items[slice_index] = .{ .slice = .{ .lhs = lhs_index, .start = start_index, .end = end_index } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .sliceIndex = slice_index },
+            };
+        },
+        .slice_sentinel => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.SliceSentinel, pl_node.payload_index);
+
+            const slice_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, .{ .slice = .{ .lhs = 0, .start = 0 } });
+
+            var lhs: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.lhs,
+                false,
+            );
+            var start: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.start,
+                false,
+            );
+            var end: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.end,
+                false,
+            );
+            var sentinel: DocData.WalkResult = try self.walkRef(
+                file,
+                parent_scope,
+                extra.data.sentinel,
+                false,
+            );
+
+            const lhs_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, lhs.expr);
+            const start_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, start.expr);
+            const end_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, end.expr);
+            const sentinel_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, sentinel.expr);
+            self.exprs.items[slice_index] = .{ .slice = .{ .lhs = lhs_index, .start = start_index, .end = end_index, .sentinel = sentinel_index } };
+
+            return DocData.WalkResult{
+                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .expr = .{ .sliceIndex = slice_index },
+            };
+        },
         .bit_or => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
@@ -1924,6 +2059,7 @@ fn walkInstruction(
             };
         },
 
+        // builtin functions
         .align_of,
         .bool_to_int,
         .embed_file,
@@ -1966,6 +2102,8 @@ fn walkInstruction(
                 .expr = .{ .builtinIndex = bin_index },
             };
         },
+        // @check
+        // .clz, .ctz, .pop_count, .byte_swap, .bit_reverse
         .float_to_int, .int_to_float, .int_to_ptr, .int_to_enum, .float_cast, .int_cast, .ptr_cast, .truncate, .align_cast, .has_decl, .has_field => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);

From dd9a01818562dd4a34479d867ae0521b236fbf7b Mon Sep 17 00:00:00 2001
From: Vallahor 
Date: Wed, 1 Jun 2022 16:45:04 -0300
Subject: [PATCH 101/137] fix: slice_start, slice_end and slice_sentinel
 typeRef are now showing the slice type

---
 lib/docs/main.js | 4 ----
 src/Autodoc.zig  | 6 +++---
 2 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 277389ddf5..b16d710ee1 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1092,7 +1092,6 @@ var zigAnalysis;
             let payloadHtml = "";
             const lhsExpr = zigAnalysis.exprs[expr.slice.lhs];
             const startExpr = zigAnalysis.exprs[expr.slice.start];
-            console.log(expr)
             let decl = exprName(lhsExpr);
             let start = exprName(startExpr);
             let end = "";
@@ -1119,8 +1118,6 @@ var zigAnalysis;
             for (let i = 0; i < expr.switchOp.cases.length; i++) {
               const caseIndex = expr.switchOp.cases[i];
               const item = zigAnalysis.exprs[caseIndex];
-              console.log(caseIndex);
-              console.log(item);
               if (item['enumLiteral']) {
                 payloadHtml += "   " + " ." + exprName(item, opts) + " => {} " + "
    ";
                 continue;
@@ -1130,7 +1127,6 @@ var zigAnalysis;
               if (expr.switchOp.else_index !== 0) {
                 const else_index = expr.switchOp.else_index;
                 const item = zigAnalysis.exprs[else_index];
-                console.log(item);
                 payloadHtml += "    " + "else" + " => {} " + "
    ";
               }
               payloadHtml += "}";
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 88e0354af0..974bb3ab5e 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -1151,7 +1151,7 @@ fn walkInstruction(
             self.exprs.items[slice_index] = .{ .slice = .{ .lhs = lhs_index, .start = start_index } };
 
             return DocData.WalkResult{
-                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .typeRef = self.decls.items[lhs.expr.declRef].value.typeRef,
                 .expr = .{ .sliceIndex = slice_index },
             };
         },
@@ -1190,7 +1190,7 @@ fn walkInstruction(
             self.exprs.items[slice_index] = .{ .slice = .{ .lhs = lhs_index, .start = start_index, .end = end_index } };
 
             return DocData.WalkResult{
-                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .typeRef = self.decls.items[lhs.expr.declRef].value.typeRef,
                 .expr = .{ .sliceIndex = slice_index },
             };
         },
@@ -1237,7 +1237,7 @@ fn walkInstruction(
             self.exprs.items[slice_index] = .{ .slice = .{ .lhs = lhs_index, .start = start_index, .end = end_index, .sentinel = sentinel_index } };
 
             return DocData.WalkResult{
-                .typeRef = .{ .type = @enumToInt(Ref.type_type) },
+                .typeRef = self.decls.items[lhs.expr.declRef].value.typeRef,
                 .expr = .{ .sliceIndex = slice_index },
             };
         },

From 06ee275295b6e0674557069a09af0c3d037ff046 Mon Sep 17 00:00:00 2001
From: Loris Cro 
Date: Thu, 2 Jun 2022 16:29:22 +0200
Subject: [PATCH 102/137] autodoc: fix crash when handling siwtch_block
 instructions

---
 src/Autodoc.zig | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 974bb3ab5e..c7992de036 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -2679,10 +2679,15 @@ fn walkInstruction(
                     array_data[scalar_i] = item.expr.as.exprArg;
 
                     const body_ref = @intToEnum(Ref, file.zir.extra[extra_index]);
-                    const body_item = try self.walkRef(file, parent_scope, body_ref, false);
-                    _ = body_item;
+                    if (extra.data.bits.is_ref) {
+                        const body_item = try self.walkRef(file, parent_scope, body_ref, false);
+                        _ = body_item;
 
-                    array_data[scalar_i] = item.expr.as.exprArg;
+                        array_data[scalar_i] = item.expr.as.exprArg;
+                    } else {
+                        array_data[scalar_i] = 0;
+                        // TODO: this is wrong, decide an actual strategy
+                    }
                     // std.debug.print("{s}\n", .{sep});
                     // std.debug.print("body item_ref = {any}\n", .{item_ref});
                     // std.debug.print("body item = {any}\n", .{item});

From 918475e2e2fbaf840653b23b59d3e014fcdc7b99 Mon Sep 17 00:00:00 2001
From: Loris Cro 
Date: Thu, 2 Jun 2022 18:51:43 +0200
Subject: [PATCH 103/137] autodoc: new design for function list

---
 lib/docs/index.html | 11 ++++++++---
 lib/docs/main.js    |  6 +++++-
 2 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index a786e2879d..b128daf4c6 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -342,6 +342,13 @@
         cursor: default;
       }
 
+	  #listFns dt {
+		  font-family: var(--mono);
+	  }
+	  .argBreaker {
+		  display: none;
+	  }
+
       /* tokens */
       .tok-kw {
           color: #333;
@@ -613,9 +620,7 @@