@zigc/lib 0.17.0-dev.27 → 0.17.0-dev.292

package/std/zig/Zir.zig

@@ -250,9 +250,6 @@ pub const Inst = struct {
         /// Array concatenation. `a ++ b`
         /// Uses the `pl_node` union field. Payload is `Bin`.
         array_cat,
-        /// Array multiplication `a ** b`
-        /// Uses the `pl_node` union field. Payload is `ArrayMul`.
-        array_mul,
         /// `[N]T` syntax. No source location provided.
         /// Uses the `pl_node` union field. Payload is `Bin`. lhs is length, rhs is element type.
         array_type,
@@ -597,13 +594,6 @@ pub const Inst = struct {
         /// name is added to it.
         /// Uses the `str_tok` union field.
         ret_err_value,
-        /// A string name is provided which is an anonymous error set value.
-        /// If the current function has an inferred error set, the error given by the
-        /// name is added to it.
-        /// Results in the error code. Note that control flow is not diverted with
-        /// this instruction; a following 'ret' instruction will do the diversion.
-        /// Uses the `str_tok` union field.
-        ret_err_value_code,
         /// Obtains a pointer to the return value.
         /// Uses the `node` union field.
         ret_ptr,
@@ -1016,9 +1006,6 @@ pub const Inst = struct {
         /// Implements the `@max` builtin for 2 args.
         /// Uses the `pl_node` union field with payload `Bin`
         max,
-        /// Implements the `@cImport` builtin.
-        /// Uses the `pl_node` union field with payload `Block`.
-        c_import,
 
         /// Allocates stack local memory.
         /// Uses the `un_node` union field. The operand is the type of the allocated object.
@@ -1069,9 +1056,6 @@ pub const Inst = struct {
         /// A defer statement.
         /// Uses the `defer` union field.
         @"defer",
-        /// An errdefer statement with a code.
-        /// Uses the `err_defer_code` union field.
-        defer_err_code,
 
         /// Requests that Sema update the saved error return trace index for the enclosing
         /// block, if the operand is .none or of an error/error-union type.
@@ -1115,7 +1099,6 @@ pub const Inst = struct {
                 .alloc_inferred_comptime_mut,
                 .make_ptr_const,
                 .array_cat,
-                .array_mul,
                 .array_type,
                 .array_type_sentinel,
                 .reify_int,
@@ -1297,16 +1280,13 @@ pub const Inst = struct {
                 .memset,
                 .memmove,
                 .min,
-                .c_import,
                 .@"resume",
-                .ret_err_value_code,
                 .extended,
                 .ret_ptr,
                 .ret_type,
                 .@"try",
                 .try_ptr,
                 .@"defer",
-                .defer_err_code,
                 .save_err_ret_index,
                 .for_len,
                 .opt_eu_base_ptr_init,
@@ -1381,7 +1361,6 @@ pub const Inst = struct {
                 .memmove,
                 .check_comptime_control_flow,
                 .@"defer",
-                .defer_err_code,
                 .save_err_ret_index,
                 .restore_err_ret_index_unconditional,
                 .restore_err_ret_index_fn_entry,
@@ -1413,7 +1392,6 @@ pub const Inst = struct {
                 .resolve_inferred_alloc,
                 .make_ptr_const,
                 .array_cat,
-                .array_mul,
                 .array_type,
                 .array_type_sentinel,
                 .reify_int,
@@ -1577,9 +1555,7 @@ pub const Inst = struct {
                 .builtin_call,
                 .max,
                 .min,
-                .c_import,
                 .@"resume",
-                .ret_err_value_code,
                 .@"break",
                 .break_inline,
                 .condbr,
@@ -1649,7 +1625,6 @@ pub const Inst = struct {
                 .param_anytype = .str_tok,
                 .param_anytype_comptime = .str_tok,
                 .array_cat = .pl_node,
-                .array_mul = .pl_node,
                 .array_type = .pl_node,
                 .array_type_sentinel = .pl_node,
                 .reify_int = .pl_node,
@@ -1737,7 +1712,6 @@ pub const Inst = struct {
                 .ret_load = .un_node,
                 .ret_implicit = .un_tok,
                 .ret_err_value = .str_tok,
-                .ret_err_value_code = .str_tok,
                 .ret_ptr = .node,
                 .ret_type = .node,
                 .ptr_type = .ptr_type,
@@ -1857,7 +1831,6 @@ pub const Inst = struct {
                 .memset = .pl_node,
                 .memmove = .pl_node,
                 .min = .pl_node,
-                .c_import = .pl_node,
 
                 .alloc = .un_node,
                 .alloc_mut = .un_node,
@@ -1872,7 +1845,6 @@ pub const Inst = struct {
                 .@"resume" = .un_node,
 
                 .@"defer" = .@"defer",
-                .defer_err_code = .defer_err_code,
 
                 .save_err_ret_index = .save_err_ret_index,
                 .restore_err_ret_index_unconditional = .un_node,
@@ -2018,12 +1990,6 @@ pub const Inst = struct {
         /// `small` is unused.
         round_op_ty,
         /// `operand` is payload index to `UnNode`.
-        c_undef,
-        /// `operand` is payload index to `UnNode`.
-        c_include,
-        /// `operand` is payload index to `BinNode`.
-        c_define,
-        /// `operand` is payload index to `UnNode`.
         wasm_memory_size,
         /// `operand` is payload index to `BinNode`.
         wasm_memory_grow,
@@ -2153,10 +2119,10 @@ pub const Inst = struct {
         /// Guaranteed to not have the `ptr_cast` flag.
         /// Uses the `pl_node` union field with payload `FieldParentPtr`.
         field_parent_ptr,
-        /// Get a type or value from `std.builtin`.
+        /// Get a type or value from `std.lang`.
         /// `operand` is `src_node: Ast.Node.Offset`.
-        /// `small` is an `Inst.BuiltinValue`.
-        builtin_value,
+        /// `small` is an `Inst.StdLangValue`.
+        std_lang_value,
         /// Provide a `@branchHint` for the current block.
         /// `operand` is payload index to `UnNode`.
         /// `small` is unused.
@@ -2225,7 +2191,6 @@ pub const Inst = struct {
     /// and `[]Ref`.
     pub const Ref = enum(u32) {
         u0_type,
-        i0_type,
         u1_type,
         u8_type,
         i8_type,
@@ -2453,7 +2418,7 @@ pub const Inst = struct {
                 has_bit_range: bool,
                 _: u1 = 0,
             },
-            size: std.builtin.Type.Pointer.Size,
+            size: std.lang.Type.Pointer.Size,
             /// Index into extra. See `PtrType`.
             payload_index: u32,
         },
@@ -2461,7 +2426,7 @@ pub const Inst = struct {
             /// Offset from Decl AST node index.
             /// `Tag` determines which kind of AST node this points to.
             src_node: Ast.Node.Offset,
-            signedness: std.builtin.Signedness,
+            signedness: std.lang.Signedness,
             bit_count: u16,
         },
         @"unreachable": struct {
@@ -2496,10 +2461,6 @@ pub const Inst = struct {
             index: u32,
             len: u32,
         },
-        defer_err_code: struct {
-            err_code: Ref,
-            payload_index: u32,
-        },
         save_err_ret_index: struct {
             operand: Ref, // If error type (or .none), save new trace index
         },
@@ -2550,7 +2511,6 @@ pub const Inst = struct {
             inst_node,
             str_op,
             @"defer",
-            defer_err_code,
             save_err_ret_index,
             elem_val_imm,
             declaration,
@@ -3091,7 +3051,7 @@ pub const Inst = struct {
         callee: Ref,
 
         pub const Flags = packed struct {
-            /// std.builtin.CallModifier in packed form
+            /// std.lang.CallModifier in packed form
             pub const PackedModifier = u3;
             pub const PackedArgsLen = u27;
 
@@ -3103,7 +3063,7 @@ pub const Inst = struct {
             comptime {
                 if (@sizeOf(Flags) != 4 or @bitSizeOf(Flags) != 32)
                     @compileError("Layout of Call.Flags needs to be updated!");
-                if (@bitSizeOf(std.builtin.CallModifier) != @bitSizeOf(PackedModifier))
+                if (@bitSizeOf(std.lang.CallModifier) != @bitSizeOf(PackedModifier))
                     @compileError("Call.Flags.PackedModifier needs to be updated!");
             }
         };
@@ -3226,7 +3186,7 @@ pub const Inst = struct {
 
     pub const ReifySliceArgInfo = enum(u16) {
         /// Input element type is `type`.
-        /// Output element type is `std.builtin.Type.Fn.Param.Attributes`.
+        /// Output element type is `std.lang.Type.Fn.Param.Attributes`.
         type_to_fn_param_attrs,
         /// Input element type is `[]const u8`.
         /// Output element type is `type`.
@@ -3234,10 +3194,10 @@ pub const Inst = struct {
         /// Identical to `string_to_struct_field_type` aside from emitting slightly different error messages.
         string_to_union_field_type,
         /// Input element type is `[]const u8`.
-        /// Output element type is `std.builtin.Type.StructField.Attributes`.
+        /// Output element type is `std.lang.Type.StructField.Attributes`.
         string_to_struct_field_attrs,
         /// Input element type is `[]const u8`.
-        /// Output element type is `std.builtin.Type.UnionField.Attributes`.
+        /// Output element type is `std.lang.Type.UnionField.Attributes`.
         string_to_union_field_attrs,
     };
 
@@ -3508,7 +3468,7 @@ pub const Inst = struct {
             has_decls_len: bool,
             has_fields_len: bool,
             name_strategy: NameStrategy,
-            layout: std.builtin.Type.ContainerLayout,
+            layout: std.lang.Type.ContainerLayout,
             /// Always `false` if `layout != .@"packed"`.
             has_backing_int_type: bool,
             any_field_aligns: bool,
@@ -3604,7 +3564,7 @@ pub const Inst = struct {
         }
     };
 
-    pub const BuiltinValue = enum(u16) {
+    pub const StdLangValue = enum(u16) {
         // Types
         atomic_order,
         atomic_rmw_op,
@@ -3728,7 +3688,7 @@ pub const Inst = struct {
                 };
             }
 
-            pub fn layout(k: Kind) std.builtin.Type.ContainerLayout {
+            pub fn layout(k: Kind) std.lang.Type.ContainerLayout {
                 return switch (k) {
                     .auto, .tagged_explicit, .tagged_enum, .tagged_enum_explicit => .auto,
                     .@"extern" => .@"extern",
@@ -3986,12 +3946,6 @@ pub const Inst = struct {
         column: u32,
     };
 
-    pub const DeferErrCode = struct {
-        remapped_err_code: Index,
-        index: u32,
-        len: u32,
-    };
-
     pub const ValidateDestructure = struct {
         /// The value being destructured.
         operand: Ref,
@@ -4001,15 +3955,6 @@ pub const Inst = struct {
         expect_len: u32,
     };
 
-    pub const ArrayMul = struct {
-        /// The result type of the array multiplication operation, or `.none` if none was available.
-        res_ty: Ref,
-        /// The LHS of the array multiplication.
-        lhs: Ref,
-        /// The RHS of the array multiplication.
-        rhs: Ref,
-    };
-
     pub const RestoreErrRetIndex = struct {
         src_node: Ast.Node.Offset,
         /// If `.none`, restore the trace to its state upon function entry.
@@ -4033,30 +3978,30 @@ pub const DeclContents = struct {
     /// This is a simple optional because ZIR guarantees that a `func`/`func_inferred`/`func_fancy` instruction
     /// can only occur once per `declaration`.
     func_decl: ?Inst.Index,
-    explicit_types: std.ArrayList(Inst.Index),
+    type_decls: std.ArrayList(Inst.Index),
     other: std.ArrayList(Inst.Index),
 
     pub const init: DeclContents = .{
         .func_decl = null,
-        .explicit_types = .empty,
+        .type_decls = .empty,
         .other = .empty,
     };
 
     pub fn clear(contents: *DeclContents) void {
         contents.func_decl = null;
-        contents.explicit_types.clearRetainingCapacity();
+        contents.type_decls.clearRetainingCapacity();
         contents.other.clearRetainingCapacity();
     }
 
     pub fn deinit(contents: *DeclContents, gpa: Allocator) void {
-        contents.explicit_types.deinit(gpa);
+        contents.type_decls.deinit(gpa);
         contents.other.deinit(gpa);
     }
 };
 
 /// Find all tracked ZIR instructions, recursively, within a `declaration` instruction. Does not recurse through
 /// nested declarations; to find all declarations, call this function recursively on the type declarations discovered
-/// in `contents.explicit_types`.
+/// in `contents.type_decls`.
 ///
 /// This populates an `ArrayList` because an iterator would need to allocate memory anyway.
 pub fn findTrackable(zir: Zir, gpa: Allocator, contents: *DeclContents, decl_inst: Zir.Inst.Index) !void {
@@ -4076,15 +4021,49 @@ pub fn findTrackable(zir: Zir, gpa: Allocator, contents: *DeclContents, decl_ins
     if (decl.value_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
 }
 
-/// Like `findTrackable`, but only considers the `main_struct_inst` instruction. This may return more than
-/// just that instruction because it will also traverse fields.
-pub fn findTrackableRoot(zir: Zir, gpa: Allocator, contents: *DeclContents) !void {
+/// `findTrackable` does not recurse into field expressions in a type. Instead, this function will
+/// scan specifically field expressions in a given type declaration for trackable ZIR instructions.
+pub fn findTrackableFields(
+    zir: *const Zir,
+    gpa: Allocator,
+    contents: *DeclContents,
+    type_decl_inst: Zir.Inst.Index,
+) Allocator.Error!void {
     contents.clear();
 
     var found_defers: std.AutoHashMapUnmanaged(u32, void) = .empty;
     defer found_defers.deinit(gpa);
 
-    try zir.findTrackableInner(gpa, contents, &found_defers, .main_struct_inst);
+    assert(zir.instructions.items(.tag)[@intFromEnum(type_decl_inst)] == .extended);
+    switch (zir.instructions.items(.data)[@intFromEnum(type_decl_inst)].extended.opcode) {
+        .struct_decl => {
+            const struct_decl = zir.getStructDecl(type_decl_inst);
+            var it = struct_decl.iterateFields();
+            while (it.next()) |field| {
+                try zir.findTrackableBody(gpa, contents, &found_defers, field.type_body);
+                if (field.align_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
+                if (field.default_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
+            }
+        },
+        .union_decl => {
+            const union_decl = zir.getUnionDecl(type_decl_inst);
+            var it = union_decl.iterateFields();
+            while (it.next()) |field| {
+                if (field.type_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
+                if (field.align_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
+                if (field.value_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
+            }
+        },
+        .enum_decl => {
+            const enum_decl = zir.getEnumDecl(type_decl_inst);
+            var it = enum_decl.iterateFields();
+            while (it.next()) |field| {
+                if (field.value_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
+            }
+        },
+        .opaque_decl => {},
+        else => unreachable,
+    }
 }
 
 fn findTrackableInner(
@@ -4127,7 +4106,6 @@ fn findTrackableInner(
         .param_anytype,
         .param_anytype_comptime,
         .array_cat,
-        .array_mul,
         .array_type,
         .array_type_sentinel,
         .reify_int,
@@ -4200,7 +4178,6 @@ fn findTrackableInner(
         .ret_load,
         .ret_implicit,
         .ret_err_value,
-        .ret_err_value_code,
         .ret_ptr,
         .ret_type,
         .ptr_type,
@@ -4360,9 +4337,6 @@ fn findTrackableInner(
                 .mul_with_overflow,
                 .shl_with_overflow,
                 .round_op,
-                .c_undef,
-                .c_include,
-                .c_define,
                 .wasm_memory_size,
                 .wasm_memory_grow,
                 .prefetch,
@@ -4394,7 +4368,7 @@ fn findTrackableInner(
                 .restore_err_ret_index,
                 .closure_get,
                 .field_parent_ptr,
-                .builtin_value,
+                .std_lang_value,
                 .branch_hint,
                 .inplace_arith_result_ty,
                 .tuple_decl,
@@ -4411,49 +4385,18 @@ fn findTrackableInner(
                     try zir.findTrackableBody(gpa, contents, defers, body);
                 },
 
-                // Reifications and opaque declarations need tracking, but have no bodies.
+                // Reifications need tracking.
                 .reify_enum,
                 .reify_struct,
                 .reify_union,
-                .opaque_decl,
                 => return contents.other.append(gpa, inst),
 
-                // Struct declarations need tracking and have bodies.
-                .struct_decl => {
-                    try contents.explicit_types.append(gpa, inst);
-
-                    const struct_decl = zir.getStructDecl(inst);
-                    var it = struct_decl.iterateFields();
-                    while (it.next()) |field| {
-                        try zir.findTrackableBody(gpa, contents, defers, field.type_body);
-                        if (field.align_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
-                        if (field.default_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
-                    }
-                },
-
-                // Union declarations need tracking and have bodies.
-                .union_decl => {
-                    try contents.explicit_types.append(gpa, inst);
-
-                    const union_decl = zir.getUnionDecl(inst);
-                    var it = union_decl.iterateFields();
-                    while (it.next()) |field| {
-                        if (field.type_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
-                        if (field.align_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
-                        if (field.value_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
-                    }
-                },
-
-                // Enum declarations need tracking and have bodies.
-                .enum_decl => {
-                    try contents.explicit_types.append(gpa, inst);
-
-                    const enum_decl = zir.getEnumDecl(inst);
-                    var it = enum_decl.iterateFields();
-                    while (it.next()) |field| {
-                        if (field.value_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
-                    }
-                },
+                // Type declarations need tracking.
+                .struct_decl,
+                .union_decl,
+                .enum_decl,
+                .opaque_decl,
+                => return contents.type_decls.append(gpa, inst),
             }
         },
 
@@ -4532,7 +4475,6 @@ fn findTrackableInner(
 
         .block,
         .block_inline,
-        .c_import,
         .typeof_builtin,
         .loop,
         => {
@@ -4634,15 +4576,6 @@ fn findTrackableInner(
                 try zir.findTrackableBody(gpa, contents, defers, body);
             }
         },
-        .defer_err_code => {
-            const inst_data = datas[@intFromEnum(inst)].defer_err_code;
-            const extra = zir.extraData(Inst.DeferErrCode, inst_data.payload_index).data;
-            const gop = try defers.getOrPut(gpa, extra.index);
-            if (!gop.found_existing) {
-                const body = zir.bodySlice(extra.index, extra.len);
-                try zir.findTrackableBody(gpa, contents, defers, body);
-            }
-        },
     }
 }
 
@@ -5353,7 +5286,7 @@ pub const UnwrappedStructDecl = struct {
 
     decls: []const Inst.Index,
 
-    layout: std.builtin.Type.ContainerLayout,
+    layout: std.lang.Type.ContainerLayout,
     backing_int_type_body: ?[]const Inst.Index,
 
     field_names: []const NullTerminatedString,

package/std/zig/ZonGen.zig

@@ -67,38 +67,30 @@ pub fn generate(gpa: Allocator, tree: Ast, options: Options) Allocator.Error!Zoi
     }
 
     if (zg.compile_errors.items.len > 0) {
-        const string_bytes = try zg.string_bytes.toOwnedSlice(gpa);
-        errdefer gpa.free(string_bytes);
-        const compile_errors = try zg.compile_errors.toOwnedSlice(gpa);
-        errdefer gpa.free(compile_errors);
-        const error_notes = try zg.error_notes.toOwnedSlice(gpa);
-        errdefer gpa.free(error_notes);
+        try zg.string_bytes.shrinkToLen(gpa);
+        try zg.compile_errors.shrinkToLen(gpa);
+        try zg.error_notes.shrinkToLen(gpa);
 
         return .{
             .nodes = .empty,
             .extra = &.{},
             .limbs = &.{},
-            .string_bytes = string_bytes,
-            .compile_errors = compile_errors,
-            .error_notes = error_notes,
+            .string_bytes = zg.string_bytes.toOwnedSliceAssert(),
+            .compile_errors = zg.compile_errors.toOwnedSliceAssert(),
+            .error_notes = zg.error_notes.toOwnedSliceAssert(),
         };
     } else {
         assert(zg.error_notes.items.len == 0);
 
-        var nodes = zg.nodes.toOwnedSlice();
-        errdefer nodes.deinit(gpa);
-        const extra = try zg.extra.toOwnedSlice(gpa);
-        errdefer gpa.free(extra);
-        const limbs = try zg.limbs.toOwnedSlice(gpa);
-        errdefer gpa.free(limbs);
-        const string_bytes = try zg.string_bytes.toOwnedSlice(gpa);
-        errdefer gpa.free(string_bytes);
+        try zg.extra.shrinkToLen(gpa);
+        try zg.limbs.shrinkToLen(gpa);
+        try zg.string_bytes.shrinkToLen(gpa);
 
         return .{
-            .nodes = nodes,
-            .extra = extra,
-            .limbs = limbs,
-            .string_bytes = string_bytes,
+            .nodes = zg.nodes.toOwnedSlice(),
+            .extra = zg.extra.toOwnedSliceAssert(),
+            .limbs = zg.limbs.toOwnedSliceAssert(),
+            .string_bytes = zg.string_bytes.toOwnedSliceAssert(),
             .compile_errors = &.{},
             .error_notes = &.{},
         };
@@ -174,7 +166,6 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator
         .less_than,
         .less_or_equal,
         .array_cat,
-        .array_mult,
         .bool_and,
         .bool_or,
         .bool_not,
@@ -427,10 +418,11 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator
             });
 
             // For short initializers, track the names on the stack rather than going through gpa.
-            var sfba_state = std.heap.stackFallback(256, gpa);
-            const sfba = sfba_state.get();
+            var bfa_buf: [256]u8 = undefined;
+            var bfa_state: std.heap.BufferFirstAllocator = .init(&bfa_buf, gpa);
+            const bfa = bfa_state.allocator();
             var field_names: std.AutoHashMapUnmanaged(Zoir.NullTerminatedString, Ast.TokenIndex) = .empty;
-            defer field_names.deinit(sfba);
+            defer field_names.deinit(bfa);
 
             var reported_any_duplicate = false;
 
@@ -438,7 +430,7 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator
                 const name_token = tree.firstToken(elem_node) - 2;
                 if (zg.identAsString(name_token)) |name_str| {
                     zg.extra.items[extra_name_idx] = @intFromEnum(name_str);
-                    const gop = try field_names.getOrPut(sfba, name_str);
+                    const gop = try field_names.getOrPut(bfa, name_str);
                     if (gop.found_existing and !reported_any_duplicate) {
                         reported_any_duplicate = true;
                         const earlier_token = gop.value_ptr.*;
@@ -667,7 +659,7 @@ fn numberLiteral(zg: *ZonGen, num_node: Ast.Node.Index, src_node: Ast.Node.Index
             big_int.setString(@intFromEnum(base), num_without_prefix) catch |err| switch (err) {
                 error.InvalidCharacter => unreachable, // caught in `parseNumberLiteral`
                 error.InvalidBase => unreachable, // we only pass 16, 8, 2, see above
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
             };
             switch (sign) {
                 .positive => {},