mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-06 06:13:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

std.fmt: require specifier for unwrapping ?T and E!T

Browse Source
This commit is contained in:
InKryption 2022-07-25 15:29:07 +03:00 committed by Andrew Kelley
parent 1a16b7214d
commit a0d3a87ce1
14 changed files with 70 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
doc/langref.html.in
View File

@ -574,7 +574,7 @@ pub fn main() void {
var optional_value: ?[]const u8 = null; var optional_value: ?[]const u8 = null;
assert(optional_value == null); assert(optional_value == null);
print("\noptional 1\ntype: {s}\nvalue: {s}\n", .{ print("\noptional 1\ntype: {s}\nvalue: {?s}\n", .{
@typeName(@TypeOf(optional_value)), @typeName(@TypeOf(optional_value)),
optional_value, optional_value,
}); });
@ -582,7 +582,7 @@ pub fn main() void {
optional_value = "hi"; optional_value = "hi";
assert(optional_value != null); assert(optional_value != null);
print("\noptional 2\ntype: {s}\nvalue: {s}\n", .{ print("\noptional 2\ntype: {s}\nvalue: {?s}\n", .{
@typeName(@TypeOf(optional_value)), @typeName(@TypeOf(optional_value)),
optional_value, optional_value,
}); });
@ -590,14 +590,14 @@ pub fn main() void {
// error union // error union
var number_or_error: anyerror!i32 = error.ArgNotFound; var number_or_error: anyerror!i32 = error.ArgNotFound;
print("\nerror union 1\ntype: {s}\nvalue: {}\n", .{ print("\nerror union 1\ntype: {s}\nvalue: {!}\n", .{
@typeName(@TypeOf(number_or_error)), @typeName(@TypeOf(number_or_error)),
number_or_error, number_or_error,
}); });
number_or_error = 1234; number_or_error = 1234;
print("\nerror union 2\ntype: {s}\nvalue: {}\n", .{ print("\nerror union 2\ntype: {s}\nvalue: {!}\n", .{
@typeName(@TypeOf(number_or_error)), @typeName(@TypeOf(number_or_error)),
number_or_error, number_or_error,
}); });

4
lib/std/build.zig
View File

@ -751,7 +751,7 @@ pub const Builder = struct {
\\Available CPU features for architecture '{s}': \\Available CPU features for architecture '{s}':
\\ \\
, .{ , .{
diags.unknown_feature_name, diags.unknown_feature_name.?,
@tagName(diags.arch.?), @tagName(diags.arch.?),
}); });
for (diags.arch.?.allFeaturesList()) |feature| { for (diags.arch.?.allFeaturesList()) |feature| {
@ -765,7 +765,7 @@ pub const Builder = struct {
\\Unknown OS: '{s}' \\Unknown OS: '{s}'
\\Available operating systems: \\Available operating systems:
\\ \\
, .{diags.os_name}); , .{diags.os_name.?});
inline for (std.meta.fields(std.Target.Os.Tag)) |field| { inline for (std.meta.fields(std.Target.Os.Tag)) |field| {
log.err(" {s}", .{field.name}); log.err(" {s}", .{field.name});
} }

2
lib/std/crypto/phc_encoding.zig
View File

@ -216,7 +216,7 @@ fn serializeTo(params: anytype, out: anytype) !void {
var has_params = false; var has_params = false;
inline for (comptime meta.fields(HashResult)) |p| { inline for (comptime meta.fields(HashResult)) |p| {
if (!(mem.eql(u8, p.name, "alg_id") or if (comptime !(mem.eql(u8, p.name, "alg_id") or
mem.eql(u8, p.name, "alg_version") or mem.eql(u8, p.name, "alg_version") or
mem.eql(u8, p.name, "hash") or mem.eql(u8, p.name, "hash") or
mem.eql(u8, p.name, "salt"))) mem.eql(u8, p.name, "salt")))

44
lib/std/fmt.zig
View File

@ -60,8 +60,10 @@ pub const FormatOptions = struct {
/// - `o`: output integer value in octal notation /// - `o`: output integer value in octal notation
/// - `c`: output integer as an ASCII character. Integer type must have 8 bits at max. /// - `c`: output integer as an ASCII character. Integer type must have 8 bits at max.
/// - `u`: output integer as an UTF-8 sequence. Integer type must have 21 bits at max. /// - `u`: output integer as an UTF-8 sequence. Integer type must have 21 bits at max.
/// - `?`: output optional value as either the unwrapped value, or `null`; may be followed by a format specifier for the underlying value.
/// - `!`: output error union value as either the unwrapped value, or the formatted error value; may be followed by a format specifier for the underlying value.
/// - `*`: output the address of the value instead of the value itself. /// - `*`: output the address of the value instead of the value itself.
/// - `any`: output a value of any type using its default format /// - `any`: output a value of any type using its default format.
/// ///
/// If a formatted user type contains a function of the type /// If a formatted user type contains a function of the type
/// ``` /// ```
@ -438,12 +440,20 @@ fn defaultSpec(comptime T: type) [:0]const u8 {
.Many, .C => return "*", .Many, .C => return "*",
.Slice => return ANY, .Slice => return ANY,
}, },
.Optional => |info| return defaultSpec(info.child), .Optional => |info| return "?" ++ defaultSpec(info.child),
.ErrorUnion => |info| return "!" ++ defaultSpec(info.payload),
else => {}, else => {},
} }
return ""; return "";
} }
fn stripOptionalOrErrorUnionSpec(comptime fmt: []const u8) []const u8 {
return if (std.mem.eql(u8, fmt[1..], ANY))
ANY
else
fmt[1..];
}
pub fn formatType( pub fn formatType(
value: anytype, value: anytype,
comptime fmt: []const u8, comptime fmt: []const u8,
@ -451,12 +461,18 @@ pub fn formatType(
writer: anytype, writer: anytype,
max_depth: usize, max_depth: usize,
) @TypeOf(writer).Error!void { ) @TypeOf(writer).Error!void {
const actual_fmt = comptime if (std.mem.eql(u8, fmt, ANY)) defaultSpec(@TypeOf(value)) else fmt; const T = @TypeOf(value);
const actual_fmt = comptime if (std.mem.eql(u8, fmt, ANY))
defaultSpec(@TypeOf(value))
else if (fmt.len != 0 and (fmt[0] == '?' or fmt[0] == '!')) switch (@typeInfo(T)) {
.Optional, .ErrorUnion => fmt,
else => stripOptionalOrErrorUnionSpec(fmt),
} else fmt;
if (comptime std.mem.eql(u8, actual_fmt, "*")) { if (comptime std.mem.eql(u8, actual_fmt, "*")) {
return formatAddress(value, options, writer); return formatAddress(value, options, writer);
} }
const T = @TypeOf(value);
if (comptime std.meta.trait.hasFn("format")(T)) { if (comptime std.meta.trait.hasFn("format")(T)) {
return try value.format(actual_fmt, options, writer); return try value.format(actual_fmt, options, writer);
} }
@ -472,17 +488,23 @@ pub fn formatType(
return formatBuf(if (value) "true" else "false", options, writer); return formatBuf(if (value) "true" else "false", options, writer);
}, },
.Optional => { .Optional => {
if (actual_fmt.len == 0 or actual_fmt[0] != '?')
@compileError("cannot format optional without a specifier (i.e. {?} or {any})");
const remaining_fmt = comptime stripOptionalOrErrorUnionSpec(actual_fmt);
if (value) |payload| { if (value) |payload| {
return formatType(payload, actual_fmt, options, writer, max_depth); return formatType(payload, remaining_fmt, options, writer, max_depth);
} else { } else {
return formatBuf("null", options, writer); return formatBuf("null", options, writer);
} }
}, },
.ErrorUnion => { .ErrorUnion => {
if (actual_fmt.len == 0 or actual_fmt[0] != '!')
@compileError("cannot format error union without a specifier (i.e. {!} or {any})");
const remaining_fmt = comptime stripOptionalOrErrorUnionSpec(actual_fmt);
if (value) |payload| { if (value) |payload| {
return formatType(payload, actual_fmt, options, writer, max_depth); return formatType(payload, remaining_fmt, options, writer, max_depth);
} else |err| { } else |err| {
return formatType(err, actual_fmt, options, writer, max_depth); return formatType(err, remaining_fmt, options, writer, max_depth);
} }
}, },
.ErrorSet => { .ErrorSet => {
@ -1977,11 +1999,11 @@ test "escaped braces" {
test "optional" { test "optional" {
{ {
const value: ?i32 = 1234; const value: ?i32 = 1234;
try expectFmt("optional: 1234\n", "optional: {}\n", .{value}); try expectFmt("optional: 1234\n", "optional: {?}\n", .{value});
} }
{ {
const value: ?i32 = null; const value: ?i32 = null;
try expectFmt("optional: null\n", "optional: {}\n", .{value}); try expectFmt("optional: null\n", "optional: {?}\n", .{value});
} }
{ {
const value = @intToPtr(?*i32, 0xf000d000); const value = @intToPtr(?*i32, 0xf000d000);
@ -1992,11 +2014,11 @@ test "optional" {
test "error" { test "error" {
{ {
const value: anyerror!i32 = 1234; const value: anyerror!i32 = 1234;
try expectFmt("error union: 1234\n", "error union: {}\n", .{value}); try expectFmt("error union: 1234\n", "error union: {!}\n", .{value});
} }
{ {
const value: anyerror!i32 = error.InvalidChar; const value: anyerror!i32 = error.InvalidChar;
try expectFmt("error union: error.InvalidChar\n", "error union: {}\n", .{value}); try expectFmt("error union: error.InvalidChar\n", "error union: {!}\n", .{value});
} }
} }

2
lib/std/x/os/net.zig
View File

@ -544,7 +544,7 @@ test "ip: convert to and from ipv6" {
try testing.expect(IPv4.localhost.mapToIPv6().mapsToIPv4()); try testing.expect(IPv4.localhost.mapToIPv6().mapsToIPv4());
try testing.expect(IPv4.localhost.toIPv6().toIPv4() == null); try testing.expect(IPv4.localhost.toIPv6().toIPv4() == null);
try testing.expectFmt("127.0.0.1", "{}", .{IPv4.localhost.mapToIPv6().toIPv4()}); try testing.expectFmt("127.0.0.1", "{?}", .{IPv4.localhost.mapToIPv6().toIPv4()});
} }
test "ipv4: parse & format" { test "ipv4: parse & format" {

2
src/Cache.zig
View File

@ -747,7 +747,7 @@ pub const Manifest = struct {
file.stat.inode, file.stat.inode,
file.stat.mtime, file.stat.mtime,
&encoded_digest, &encoded_digest,
file.path, file.path.?,
}); });
} }

2
src/Compilation.zig
View File

@ -1465,7 +1465,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
.handle = artifact_dir, .handle = artifact_dir,
.path = try options.local_cache_directory.join(arena, &[_][]const u8{artifact_sub_dir}), .path = try options.local_cache_directory.join(arena, &[_][]const u8{artifact_sub_dir}),
}; };
log.debug("zig_cache_artifact_directory='{s}' use_stage1={}", .{ log.debug("zig_cache_artifact_directory='{?s}' use_stage1={}", .{
zig_cache_artifact_directory.path, use_stage1, zig_cache_artifact_directory.path, use_stage1,
}); });

18
src/link/MachO.zig
View File

@ -363,7 +363,7 @@ pub fn openPath(allocator: Allocator, options: link.Options) !*MachO {
// Create dSYM bundle. // Create dSYM bundle.
const dir = options.module.?.zig_cache_artifact_directory; const dir = options.module.?.zig_cache_artifact_directory;
log.debug("creating {s}.dSYM bundle in {s}", .{ emit.sub_path, dir.path }); log.debug("creating {s}.dSYM bundle in {?s}", .{ emit.sub_path, dir.path });
const d_sym_path = try fmt.allocPrint( const d_sym_path = try fmt.allocPrint(
allocator, allocator,
@ -2378,7 +2378,7 @@ fn writeAtomsOneShot(self: *MachO) !void {
break :blk math.cast(usize, size) orelse return error.Overflow; break :blk math.cast(usize, size) orelse return error.Overflow;
} else 0; } else 0;
log.debug(" (adding ATOM(%{d}, '{s}') from object({d}) to buffer)", .{ log.debug(" (adding ATOM(%{d}, '{s}') from object({?d}) to buffer)", .{
atom.sym_index, atom.sym_index,
atom.getName(self), atom.getName(self),
atom.file, atom.file,
@ -2911,7 +2911,7 @@ fn createTentativeDefAtoms(self: *MachO) !void {
const sym = self.getSymbolPtr(global); const sym = self.getSymbolPtr(global);
if (!sym.tentative()) continue; if (!sym.tentative()) continue;
log.debug("creating tentative definition for ATOM(%{d}, '{s}') in object({d})", .{ log.debug("creating tentative definition for ATOM(%{d}, '{s}') in object({?d})", .{
global.sym_index, self.getSymbolName(global), global.file, global.sym_index, self.getSymbolName(global), global.file,
}); });
@ -3694,7 +3694,7 @@ pub fn lowerUnnamedConst(self: *MachO, typed_value: TypedValue, decl_index: Modu
}; };
const name = self.strtab.get(name_str_index); const name = self.strtab.get(name_str_index);
log.debug("allocating symbol indexes for {s}", .{name}); log.debug("allocating symbol indexes for {?s}", .{name});
const required_alignment = typed_value.ty.abiAlignment(self.base.options.target); const required_alignment = typed_value.ty.abiAlignment(self.base.options.target);
const sym_index = try self.allocateSymbol(); const sym_index = try self.allocateSymbol();
@ -3734,7 +3734,7 @@ pub fn lowerUnnamedConst(self: *MachO, typed_value: TypedValue, decl_index: Modu
); );
const addr = try self.allocateAtom(atom, code.len, required_alignment, match); const addr = try self.allocateAtom(atom, code.len, required_alignment, match);
log.debug("allocated atom for {s} at 0x{x}", .{ name, addr }); log.debug("allocated atom for {?s} at 0x{x}", .{ name, addr });
log.debug(" (required alignment 0x{x})", .{required_alignment}); log.debug(" (required alignment 0x{x})", .{required_alignment});
errdefer self.freeAtom(atom, match, true); errdefer self.freeAtom(atom, match, true);
@ -7040,7 +7040,7 @@ fn logSymtab(self: *MachO) void {
@divTrunc(sym.n_desc, macho.N_SYMBOL_RESOLVER) @divTrunc(sym.n_desc, macho.N_SYMBOL_RESOLVER)
else else
sym.n_sect; sym.n_sect;
log.debug(" %{d}: {s} @{x} in {s}({d}), {s}", .{ log.debug(" %{d}: {?s} @{x} in {s}({d}), {s}", .{
sym_id, sym_id,
self.strtab.get(sym.n_strx), self.strtab.get(sym.n_strx),
sym.n_value, sym.n_value,
@ -7053,7 +7053,7 @@ fn logSymtab(self: *MachO) void {
log.debug("globals table:", .{}); log.debug("globals table:", .{});
for (self.globals.keys()) |name, id| { for (self.globals.keys()) |name, id| {
const value = self.globals.values()[id]; const value = self.globals.values()[id];
log.debug(" {s} => %{d} in object({d})", .{ name, value.sym_index, value.file }); log.debug(" {s} => %{d} in object({?d})", .{ name, value.sym_index, value.file });
} }
log.debug("GOT entries:", .{}); log.debug("GOT entries:", .{});
@ -7068,7 +7068,7 @@ fn logSymtab(self: *MachO) void {
self.getSymbolName(entry.target), self.getSymbolName(entry.target),
}); });
} else { } else {
log.debug(" {d}@{x} => local(%{d}) in object({d}) {s}", .{ log.debug(" {d}@{x} => local(%{d}) in object({?d}) {s}", .{
i, i,
atom_sym.n_value, atom_sym.n_value,
entry.target.sym_index, entry.target.sym_index,
@ -7137,7 +7137,7 @@ fn logAtoms(self: *MachO) void {
pub fn logAtom(self: *MachO, atom: *const Atom) void { pub fn logAtom(self: *MachO, atom: *const Atom) void {
const sym = atom.getSymbol(self); const sym = atom.getSymbol(self);
const sym_name = atom.getName(self); const sym_name = atom.getName(self);
log.debug(" ATOM(%{d}, '{s}') @ {x} (sizeof({x}), alignof({x})) in object({d}) in sect({d})", .{ log.debug(" ATOM(%{d}, '{s}') @ {x} (sizeof({x}), alignof({x})) in object({?d}) in sect({d})", .{
atom.sym_index, atom.sym_index,
sym_name, sym_name,
sym.n_value, sym.n_value,

6
src/link/MachO/Atom.zig
View File

@ -541,7 +541,7 @@ pub fn resolveRelocs(self: *Atom, macho_file: *MachO) !void {
const arch = macho_file.base.options.target.cpu.arch; const arch = macho_file.base.options.target.cpu.arch;
switch (arch) { switch (arch) {
.aarch64 => { .aarch64 => {
log.debug(" RELA({s}) @ {x} => %{d} in object({d})", .{ log.debug(" RELA({s}) @ {x} => %{d} in object({?d})", .{
@tagName(@intToEnum(macho.reloc_type_arm64, rel.@"type")), @tagName(@intToEnum(macho.reloc_type_arm64, rel.@"type")),
rel.offset, rel.offset,
rel.target.sym_index, rel.target.sym_index,
@ -549,7 +549,7 @@ pub fn resolveRelocs(self: *Atom, macho_file: *MachO) !void {
}); });
}, },
.x86_64 => { .x86_64 => {
log.debug(" RELA({s}) @ {x} => %{d} in object({d})", .{ log.debug(" RELA({s}) @ {x} => %{d} in object({?d})", .{
@tagName(@intToEnum(macho.reloc_type_x86_64, rel.@"type")), @tagName(@intToEnum(macho.reloc_type_x86_64, rel.@"type")),
rel.offset, rel.offset,
rel.target.sym_index, rel.target.sym_index,
@ -579,7 +579,7 @@ pub fn resolveRelocs(self: *Atom, macho_file: *MachO) !void {
log.debug(" | atomless target '{s}'", .{target_name}); log.debug(" | atomless target '{s}'", .{target_name});
break :blk atomless_sym.n_value; break :blk atomless_sym.n_value;
}; };
log.debug(" | target ATOM(%{d}, '{s}') in object({d})", .{ log.debug(" | target ATOM(%{d}, '{s}') in object({?d})", .{
target_atom.sym_index, target_atom.sym_index,
target_atom.getName(macho_file), target_atom.getName(macho_file),
target_atom.file, target_atom.file,

2
src/link/Wasm.zig
View File

@ -1629,7 +1629,7 @@ fn setupMemory(self: *Wasm) !void {
return error.MemoryTooBig; return error.MemoryTooBig;
} }
self.memories.limits.max = @intCast(u32, max_memory / page_size); self.memories.limits.max = @intCast(u32, max_memory / page_size);
log.debug("Maximum memory pages: {d}", .{self.memories.limits.max}); log.debug("Maximum memory pages: {?d}", .{self.memories.limits.max});
} }
} }

2
src/link/Wasm/Object.zig
View File

@ -548,7 +548,7 @@ fn Parser(comptime ReaderType: type) type {
.index = try leb.readULEB128(u32, reader), .index = try leb.readULEB128(u32, reader),
.addend = if (rel_type_enum.addendIsPresent()) try leb.readULEB128(u32, reader) else null, .addend = if (rel_type_enum.addendIsPresent()) try leb.readULEB128(u32, reader) else null,
}; };
log.debug("Found relocation: type({s}) offset({d}) index({d}) addend({d})", .{ log.debug("Found relocation: type({s}) offset({d}) index({d}) addend({?d})", .{
@tagName(relocation.relocation_type), @tagName(relocation.relocation_type),
relocation.offset, relocation.offset,
relocation.index, relocation.index,

8
src/main.zig
View File

@ -3168,7 +3168,7 @@ fn parseCrossTargetOrReportFatalError(
@tagName(diags.arch.?), help_text.items, @tagName(diags.arch.?), help_text.items,
}); });
} }
fatal("Unknown CPU feature: '{s}'", .{diags.unknown_feature_name}); fatal("Unknown CPU feature: '{s}'", .{diags.unknown_feature_name.?});
}, },
else => |e| return e, else => |e| return e,
}; };
@ -3496,7 +3496,8 @@ fn cmdTranslateC(comp: *Compilation, arena: Allocator, enable_cache: bool, stage
} else { } else {
const out_zig_path = try fs.path.join(arena, &[_][]const u8{ "o", &digest, translated_zig_basename }); const out_zig_path = try fs.path.join(arena, &[_][]const u8{ "o", &digest, translated_zig_basename });
const zig_file = comp.local_cache_directory.handle.openFile(out_zig_path, .{}) catch |err| { const zig_file = comp.local_cache_directory.handle.openFile(out_zig_path, .{}) catch |err| {
fatal("unable to open cached translated zig file '{s}{s}{s}': {s}", .{ comp.local_cache_directory.path, fs.path.sep_str, out_zig_path, @errorName(err) }); const path = comp.local_cache_directory.path orelse ".";
fatal("unable to open cached translated zig file '{s}{s}{s}': {s}", .{ path, fs.path.sep_str, out_zig_path, @errorName(err) });
}; };
defer zig_file.close(); defer zig_file.close();
try io.getStdOut().writeFileAll(zig_file, .{}); try io.getStdOut().writeFileAll(zig_file, .{});
@ -3626,7 +3627,8 @@ pub fn cmdInit(
.Exe => "init-exe", .Exe => "init-exe",
}; };
var template_dir = zig_lib_directory.handle.openDir(template_sub_path, .{}) catch |err| { var template_dir = zig_lib_directory.handle.openDir(template_sub_path, .{}) catch |err| {
fatal("unable to open zig project template directory '{s}{s}{s}': {s}", .{ zig_lib_directory.path, s, template_sub_path, @errorName(err) }); const path = zig_lib_directory.path orelse ".";
fatal("unable to open zig project template directory '{s}{s}{s}': {s}", .{ path, s, template_sub_path, @errorName(err) });
}; };
defer template_dir.close(); defer template_dir.close();

2
src/register_manager.zig
View File

@ -301,7 +301,7 @@ pub fn RegisterManager(
/// register. /// register.
pub fn getReg(self: *Self, reg: Register, inst: ?Air.Inst.Index) AllocateRegistersError!void { pub fn getReg(self: *Self, reg: Register, inst: ?Air.Inst.Index) AllocateRegistersError!void {
const index = indexOfRegIntoTracked(reg) orelse return; const index = indexOfRegIntoTracked(reg) orelse return;
log.debug("getReg {} for inst {}", .{ reg, inst }); log.debug("getReg {} for inst {?}", .{ reg, inst });
self.markRegAllocated(reg); self.markRegAllocated(reg);
if (inst) |tracked_inst| if (inst) |tracked_inst|

13
src/translate_c.zig
View File

@ -2765,7 +2765,7 @@ fn transInitListExpr(
qual_type, qual_type,
)); ));
} else { } else {
const type_name = c.str(qual_type.getTypeClassName()); const type_name = try c.str(qual_type.getTypeClassName());
return fail(c, error.UnsupportedType, source_loc, "unsupported initlist type: '{s}'", .{type_name}); return fail(c, error.UnsupportedType, source_loc, "unsupported initlist type: '{s}'", .{type_name});
} }
} }
@ -4812,11 +4812,11 @@ fn transType(c: *Context, scope: *Scope, ty: *const clang.Type, source_loc: clan
}); });
}, },
.BitInt, .ExtVector => { .BitInt, .ExtVector => {
const type_name = c.str(ty.getTypeClassName()); const type_name = try c.str(ty.getTypeClassName());
return fail(c, error.UnsupportedType, source_loc, "TODO implement translation of type: '{s}'", .{type_name}); return fail(c, error.UnsupportedType, source_loc, "TODO implement translation of type: '{s}'", .{type_name});
}, },
else => { else => {
const type_name = c.str(ty.getTypeClassName()); const type_name = try c.str(ty.getTypeClassName());
return fail(c, error.UnsupportedType, source_loc, "unsupported type: '{s}'", .{type_name}); return fail(c, error.UnsupportedType, source_loc, "unsupported type: '{s}'", .{type_name});
}, },
} }
@ -5052,8 +5052,8 @@ fn finishTransFnProto(
} }
fn warn(c: *Context, scope: *Scope, loc: clang.SourceLocation, comptime format: []const u8, args: anytype) !void { fn warn(c: *Context, scope: *Scope, loc: clang.SourceLocation, comptime format: []const u8, args: anytype) !void {
const args_prefix = .{c.locStr(loc)}; const str = try c.locStr(loc);
const value = try std.fmt.allocPrint(c.arena, "// {s}: warning: " ++ format, args_prefix ++ args); const value = try std.fmt.allocPrint(c.arena, "// {s}: warning: " ++ format, .{str} ++ args);
try scope.appendNode(try Tag.warning.create(c.arena, value)); try scope.appendNode(try Tag.warning.create(c.arena, value));
} }
@ -5073,7 +5073,8 @@ pub fn failDecl(c: *Context, loc: clang.SourceLocation, name: []const u8, compti
// pub const name = @compileError(msg); // pub const name = @compileError(msg);
const fail_msg = try std.fmt.allocPrint(c.arena, format, args); const fail_msg = try std.fmt.allocPrint(c.arena, format, args);
try addTopLevelDecl(c, name, try Tag.fail_decl.create(c.arena, .{ .actual = name, .mangled = fail_msg })); try addTopLevelDecl(c, name, try Tag.fail_decl.create(c.arena, .{ .actual = name, .mangled = fail_msg }));
const location_comment = try std.fmt.allocPrint(c.arena, "// {s}", .{c.locStr(loc)}); const str = try c.locStr(loc);
const location_comment = try std.fmt.allocPrint(c.arena, "// {s}", .{str});
try c.global_scope.nodes.append(try Tag.warning.create(c.arena, location_comment)); try c.global_scope.nodes.append(try Tag.warning.create(c.arena, location_comment));
} }