From 3d78705ea5b94d7b4fa250ea51b14c46a9620092 Mon Sep 17 00:00:00 2001 From: Emil Lerch Date: Thu, 17 Oct 2024 10:54:01 -0700 Subject: [PATCH] update to latest zig nominated --- codegen/src/json.zig | 2 +- src/aws.zig | 34 ++++++++++---------- src/json.zig | 76 ++++++++++++++++++++++---------------------- src/servicemodel.zig | 2 +- src/url.zig | 12 +++---- src/xml_shaper.zig | 20 ++++++------ 6 files changed, 73 insertions(+), 73 deletions(-) diff --git a/codegen/src/json.zig b/codegen/src/json.zig index f9bfcf8..f3f4f47 100644 --- a/codegen/src/json.zig +++ b/codegen/src/json.zig @@ -2,7 +2,7 @@ const std = @import("std"); // options is a json.Options, but since we're using our hacked json.zig we don't want to // specifically call this out pub fn serializeMap(map: anytype, key: []const u8, options: anytype, out_stream: anytype) !bool { - if (@typeInfo(@TypeOf(map)) == .Optional) { + if (@typeInfo(@TypeOf(map)) == .optional) { if (map == null) return true else diff --git a/src/aws.zig b/src/aws.zig index 25745a7..06756ab 100644 --- a/src/aws.zig +++ b/src/aws.zig @@ -517,9 +517,9 @@ pub fn Request(comptime request_action: anytype) type { // And the response property below will pull whatever is the ActionResult object // We can grab index [0] as structs are guaranteed by zig to be returned in the order // declared, and we're declaring in that order in ServerResponse(). - const real_response = @field(parsed_response, @typeInfo(response_types.NormalResponse).Struct.fields[0].name); + const real_response = @field(parsed_response, @typeInfo(response_types.NormalResponse).@"struct".fields[0].name); return FullResponseType{ - .response = @field(real_response, @typeInfo(@TypeOf(real_response)).Struct.fields[0].name), + .response = @field(real_response, @typeInfo(@TypeOf(real_response)).@"struct".fields[0].name), .response_metadata = .{ .request_id = try options.client.allocator.dupe(u8, real_response.ResponseMetadata.RequestId), }, @@ -762,7 +762,7 @@ pub fn Request(comptime request_action: anytype) type { } fn coerceFromString(comptime T: type, val: []const u8) anyerror!T { - if (@typeInfo(T) == .Optional) return try coerceFromString(@typeInfo(T).Optional.child, val); + if (@typeInfo(T) == .optional) return try coerceFromString(@typeInfo(T).optional.child, val); // TODO: This is terrible...fix it switch (T) { bool => return std.ascii.eqlIgnoreCase(val, "true"), @@ -789,8 +789,8 @@ fn parseInt(comptime T: type, val: []const u8) !T { fn generalAllocPrint(allocator: std.mem.Allocator, val: anytype) !?[]const u8 { switch (@typeInfo(@TypeOf(val))) { - .Optional => if (val) |v| return generalAllocPrint(allocator, v) else return null, - .Array, .Pointer => return try std.fmt.allocPrint(allocator, "{s}", .{val}), + .optional => if (val) |v| return generalAllocPrint(allocator, v) else return null, + .array, .pointer => return try std.fmt.allocPrint(allocator, "{s}", .{val}), else => return try std.fmt.allocPrint(allocator, "{any}", .{val}), } } @@ -909,7 +909,7 @@ fn ServerResponse(comptime action: anytype) type { RequestId: []u8, }; const Result = @Type(.{ - .Struct = .{ + .@"struct" = .{ .layout = .auto, .fields = &[_]std.builtin.Type.StructField{ .{ @@ -932,7 +932,7 @@ fn ServerResponse(comptime action: anytype) type { }, }); return @Type(.{ - .Struct = .{ + .@"struct" = .{ .layout = .auto, .fields = &[_]std.builtin.Type.StructField{ .{ @@ -998,8 +998,8 @@ fn FullResponse(comptime action: anytype) type { } fn safeFree(allocator: std.mem.Allocator, obj: anytype) void { switch (@typeInfo(@TypeOf(obj))) { - .Pointer => allocator.free(obj), - .Optional => if (obj) |o| safeFree(allocator, o), + .pointer => allocator.free(obj), + .optional => if (obj) |o| safeFree(allocator, o), else => {}, } } @@ -1108,7 +1108,7 @@ fn buildQuery(allocator: std.mem.Allocator, request: anytype) ![]const u8 { var prefix = "?"; if (@hasDecl(@TypeOf(request), "http_query")) { const query_arguments = @field(@TypeOf(request), "http_query"); - inline for (@typeInfo(@TypeOf(query_arguments)).Struct.fields) |arg| { + inline for (@typeInfo(@TypeOf(query_arguments)).@"struct".fields) |arg| { const val = @field(request, arg.name); if (try addQueryArg(arg.type, prefix, @field(query_arguments, arg.name), val, writer)) prefix = "&"; @@ -1119,13 +1119,13 @@ fn buildQuery(allocator: std.mem.Allocator, request: anytype) ![]const u8 { fn addQueryArg(comptime ValueType: type, prefix: []const u8, key: []const u8, value: anytype, writer: anytype) !bool { switch (@typeInfo(@TypeOf(value))) { - .Optional => { + .optional => { if (value) |v| return try addQueryArg(ValueType, prefix, key, v, writer); return false; }, // if this is a pointer, we want to make sure it is more than just a string - .Pointer => |ptr| { + .pointer => |ptr| { if (ptr.child == u8 or ptr.size != .Slice) { // This is just a string return try addBasicQueryArg(prefix, key, value, writer); @@ -1137,7 +1137,7 @@ fn addQueryArg(comptime ValueType: type, prefix: []const u8, key: []const u8, va } return std.mem.eql(u8, "&", p); }, - .Array => |arr| { + .array => |arr| { if (arr.child == u8) return try addBasicQueryArg(prefix, key, value, writer); var p = prefix; @@ -1257,8 +1257,8 @@ fn reportTraffic( fn typeForField(comptime T: type, comptime field_name: []const u8) !type { const ti = @typeInfo(T); switch (ti) { - .Struct => { - inline for (ti.Struct.fields) |field| { + .@"struct" => { + inline for (ti.@"struct".fields) |field| { if (std.mem.eql(u8, field.name, field_name)) return field.type; } @@ -1272,7 +1272,7 @@ test "custom serialization for map objects" { const allocator = std.testing.allocator; var buffer = std.ArrayList(u8).init(allocator); defer buffer.deinit(); - var tags = try std.ArrayList(@typeInfo(try typeForField(services.lambda.tag_resource.Request, "tags")).Pointer.child).initCapacity(allocator, 2); + var tags = try std.ArrayList(@typeInfo(try typeForField(services.lambda.tag_resource.Request, "tags")).pointer.child).initCapacity(allocator, 2); defer tags.deinit(); tags.appendAssumeCapacity(.{ .key = "Foo", .value = "Bar" }); tags.appendAssumeCapacity(.{ .key = "Baz", .value = "Qux" }); @@ -2034,7 +2034,7 @@ test "rest_json_1_work_with_lambda: lambda tagResource (only), to excercise zig defer test_harness.deinit(); const options = try test_harness.start(); const lambda = (Services(.{.lambda}){}).lambda; - var tags = try std.ArrayList(@typeInfo(try typeForField(lambda.tag_resource.Request, "tags")).Pointer.child).initCapacity(allocator, 1); + var tags = try std.ArrayList(@typeInfo(try typeForField(lambda.tag_resource.Request, "tags")).pointer.child).initCapacity(allocator, 1); defer tags.deinit(); tags.appendAssumeCapacity(.{ .key = "Foo", .value = "Bar" }); const req = services.lambda.tag_resource.Request{ .resource = "arn:aws:lambda:us-west-2:550620852718:function:awsome-lambda-LambdaStackawsomeLambda", .tags = tags.items }; diff --git a/src/json.zig b/src/json.zig index b29343e..e0f4c08 100644 --- a/src/json.zig +++ b/src/json.zig @@ -1560,21 +1560,21 @@ fn skipValue(tokens: *TokenStream) SkipValueError!void { fn parseInternal(comptime T: type, token: Token, tokens: *TokenStream, options: ParseOptions) !T { switch (@typeInfo(T)) { - .Bool => { + .bool => { return switch (token) { .True => true, .False => false, else => error.UnexpectedToken, }; }, - .Float, .ComptimeFloat => { + .float, .comptime_float => { const numberToken = switch (token) { .Number => |n| n, else => return error.UnexpectedToken, }; return try std.fmt.parseFloat(T, numberToken.slice(tokens.slice, tokens.i - 1)); }, - .Int, .ComptimeInt => { + .int, .comptime_int => { const numberToken = switch (token) { .Number => |n| n, else => return error.UnexpectedToken, @@ -1587,14 +1587,14 @@ fn parseInternal(comptime T: type, token: Token, tokens: *TokenStream, options: if (std.math.round(float) != float) return error.InvalidNumber; return @as(T, @intFromFloat(float)); }, - .Optional => |optionalInfo| { + .optional => |optionalInfo| { if (token == .Null) { return null; } else { return try parseInternal(optionalInfo.child, token, tokens, options); } }, - .Enum => |enumInfo| { + .@"enum" => |enumInfo| { switch (token) { .Number => |numberToken| { if (!numberToken.is_integer) return error.UnexpectedToken; @@ -1618,7 +1618,7 @@ fn parseInternal(comptime T: type, token: Token, tokens: *TokenStream, options: else => return error.UnexpectedToken, } }, - .Union => |unionInfo| { + .@"union" => |unionInfo| { if (unionInfo.tag_type) |_| { // try each of the union fields until we find one that matches inline for (unionInfo.fields) |u_field| { @@ -1642,7 +1642,7 @@ fn parseInternal(comptime T: type, token: Token, tokens: *TokenStream, options: @compileError("Unable to parse into untagged union '" ++ @typeName(T) ++ "'"); } }, - .Struct => |structInfo| { + .@"struct" => |structInfo| { switch (token) { .ObjectBegin => {}, else => return error.UnexpectedToken, @@ -1736,7 +1736,7 @@ fn parseInternal(comptime T: type, token: Token, tokens: *TokenStream, options: } return r; }, - .Array => |arrayInfo| { + .array => |arrayInfo| { switch (token) { .ArrayBegin => { var r: T = undefined; @@ -1770,7 +1770,7 @@ fn parseInternal(comptime T: type, token: Token, tokens: *TokenStream, options: else => return error.UnexpectedToken, } }, - .Pointer => |ptrInfo| { + .pointer => |ptrInfo| { const allocator = options.allocator orelse return error.AllocatorRequired; switch (ptrInfo.size) { .One => { @@ -1863,8 +1863,8 @@ fn parseInternal(comptime T: type, token: Token, tokens: *TokenStream, options: fn typeForField(comptime T: type, comptime field_name: []const u8) ?type { const ti = @typeInfo(T); switch (ti) { - .Struct => { - inline for (ti.Struct.fields) |field| { + .@"struct" => { + inline for (ti.@"struct".fields) |field| { if (std.mem.eql(u8, field.name, field_name)) return field.type; } @@ -1878,14 +1878,14 @@ fn isMapPattern(comptime T: type) bool { // We should be getting a type that is a pointer to a slice. // Let's just double check before proceeding const ti = @typeInfo(T); - if (ti != .Pointer) return false; - if (ti.Pointer.size != .Slice) return false; - const ti_child = @typeInfo(ti.Pointer.child); - if (ti_child != .Struct) return false; - if (ti_child.Struct.fields.len != 2) return false; + if (ti != .pointer) return false; + if (ti.pointer.size != .Slice) return false; + const ti_child = @typeInfo(ti.pointer.child); + if (ti_child != .@"struct") return false; + if (ti_child.@"struct".fields.len != 2) return false; var key_found = false; var value_found = false; - inline for (ti_child.Struct.fields) |field| { + inline for (ti_child.@"struct".fields) |field| { if (std.mem.eql(u8, "key", field.name)) key_found = true; if (std.mem.eql(u8, "value", field.name)) @@ -1903,13 +1903,13 @@ pub fn parse(comptime T: type, tokens: *TokenStream, options: ParseOptions) !T { /// Should be called with the same type and `ParseOptions` that were passed to `parse` pub fn parseFree(comptime T: type, value: T, options: ParseOptions) void { switch (@typeInfo(T)) { - .Bool, .Float, .ComptimeFloat, .Int, .ComptimeInt, .Enum => {}, - .Optional => { + .bool, .float, .comptime_float, .int, .comptime_int, .@"enum" => {}, + .optional => { if (value) |v| { return parseFree(@TypeOf(v), v, options); } }, - .Union => |unionInfo| { + .@"union" => |unionInfo| { if (unionInfo.tag_type) |UnionTagType| { inline for (unionInfo.fields) |u_field| { if (value == @field(UnionTagType, u_field.name)) { @@ -1921,17 +1921,17 @@ pub fn parseFree(comptime T: type, value: T, options: ParseOptions) void { unreachable; } }, - .Struct => |structInfo| { + .@"struct" => |structInfo| { inline for (structInfo.fields) |field| { parseFree(field.type, @field(value, field.name), options); } }, - .Array => |arrayInfo| { + .array => |arrayInfo| { for (value) |v| { parseFree(arrayInfo.child, v, options); } }, - .Pointer => |ptrInfo| { + .pointer => |ptrInfo| { const allocator = options.allocator orelse unreachable; switch (ptrInfo.size) { .One => { @@ -2811,38 +2811,38 @@ pub fn stringify( ) !void { const T = @TypeOf(value); switch (@typeInfo(T)) { - .Float, .ComptimeFloat => { + .float, .comptime_float => { return std.fmt.format(out_stream, "{e}", .{value}); }, - .Int, .ComptimeInt => { + .int, .comptime_int => { return std.fmt.formatIntValue(value, "", std.fmt.FormatOptions{}, out_stream); }, - .Bool => { + .bool => { return out_stream.writeAll(if (value) "true" else "false"); }, - .Null => { + .null => { return out_stream.writeAll("null"); }, - .Optional => { + .optional => { if (value) |payload| { return try stringify(payload, options, out_stream); } else { return try stringify(null, options, out_stream); } }, - .Enum => { + .@"enum" => { if (comptime std.meta.hasFn(T, "jsonStringify")) { return value.jsonStringify(options, out_stream); } @compileError("Unable to stringify enum '" ++ @typeName(T) ++ "'"); }, - .Union => { + .@"union" => { if (comptime std.meta.hasFn(T, "jsonStringify")) { return value.jsonStringify(options, out_stream); } - const info = @typeInfo(T).Union; + const info = @typeInfo(T).@"union"; if (info.tag_type) |UnionTagType| { inline for (info.fields) |u_field| { if (value == @field(UnionTagType, u_field.name)) { @@ -2853,7 +2853,7 @@ pub fn stringify( @compileError("Unable to stringify untagged union '" ++ @typeName(T) ++ "'"); } }, - .Struct => |S| { + .@"struct" => |S| { if (comptime std.meta.hasFn(T, "jsonStringify")) { return value.jsonStringify(options, out_stream); } @@ -2869,7 +2869,7 @@ pub fn stringify( if (Field.type == void) continue; var output_this_field = true; - if (!options.emit_null and @typeInfo(Field.type) == .Optional and @field(value, Field.name) == null) output_this_field = false; + if (!options.emit_null and @typeInfo(Field.type) == .optional and @field(value, Field.name) == null) output_this_field = false; const final_name = if (comptime std.meta.hasFn(T, "fieldNameFor")) value.fieldNameFor(Field.name) @@ -2919,10 +2919,10 @@ pub fn stringify( try out_stream.writeByte('}'); return; }, - .ErrorSet => return stringify(@as([]const u8, @errorName(value)), options, out_stream), - .Pointer => |ptr_info| switch (ptr_info.size) { + .error_set => return stringify(@as([]const u8, @errorName(value)), options, out_stream), + .pointer => |ptr_info| switch (ptr_info.size) { .One => switch (@typeInfo(ptr_info.child)) { - .Array => { + .array => { const Slice = []const std.meta.Elem(ptr_info.child); return stringify(@as(Slice, value), options, out_stream); }, @@ -3001,8 +3001,8 @@ pub fn stringify( }, else => @compileError("Unable to stringify type '" ++ @typeName(T) ++ "'"), }, - .Array => return stringify(&value, options, out_stream), - .Vector => |info| { + .array => return stringify(&value, options, out_stream), + .vector => |info| { const array: [info.len]info.child = value; return stringify(&array, options, out_stream); }, diff --git a/src/servicemodel.zig b/src/servicemodel.zig index 0f26886..93cf6db 100644 --- a/src/servicemodel.zig +++ b/src/servicemodel.zig @@ -20,7 +20,7 @@ pub fn Services(comptime service_imports: anytype) type { // finally, generate the type return @Type(.{ - .Struct = .{ + .@"struct" = .{ .layout = .auto, .fields = &fields, .decls = &[_]std.builtin.Type.Declaration{}, diff --git a/src/url.zig b/src/url.zig index b2e1500..ed8e61e 100644 --- a/src/url.zig +++ b/src/url.zig @@ -24,7 +24,7 @@ fn encodeStruct( comptime options: EncodingOptions, ) !bool { var rc = first; - inline for (@typeInfo(@TypeOf(obj)).Struct.fields) |field| { + inline for (@typeInfo(@TypeOf(obj)).@"struct".fields) |field| { const field_name = try options.field_name_transformer(allocator, field.name); defer if (options.field_name_transformer.* != defaultTransformer) allocator.free(field_name); @@ -47,10 +47,10 @@ pub fn encodeInternal( // @compileLog(@typeInfo(@TypeOf(obj))); var rc = first; switch (@typeInfo(@TypeOf(obj))) { - .Optional => if (obj) |o| { + .optional => if (obj) |o| { rc = try encodeInternal(allocator, parent, field_name, first, o, writer, options); }, - .Pointer => |ti| if (ti.size == .One) { + .pointer => |ti| if (ti.size == .One) { rc = try encodeInternal(allocator, parent, field_name, first, obj.*, writer, options); } else { if (!first) _ = try writer.write("&"); @@ -61,7 +61,7 @@ pub fn encodeInternal( try writer.print("{s}{s}={any}", .{ parent, field_name, obj }); rc = false; }, - .Struct => if (std.mem.eql(u8, "", field_name)) { + .@"struct" => if (std.mem.eql(u8, "", field_name)) { rc = try encodeStruct(allocator, parent, first, obj, writer, options); } else { // TODO: It would be lovely if we could concat at compile time or allocPrint at runtime @@ -73,12 +73,12 @@ pub fn encodeInternal( rc = try encodeStruct(allocator, new_parent, first, obj, writer, options); // try encodeStruct(parent ++ field_name ++ ".", first, obj, writer, options); }, - .Array => { + .array => { if (!first) _ = try writer.write("&"); try writer.print("{s}{s}={s}", .{ parent, field_name, obj }); rc = false; }, - .Int, .ComptimeInt, .Float, .ComptimeFloat => { + .int, .comptime_int, .float, .comptime_float => { if (!first) _ = try writer.write("&"); try writer.print("{s}{s}={d}", .{ parent, field_name, obj }); rc = false; diff --git a/src/xml_shaper.zig b/src/xml_shaper.zig index e4febc6..0acd482 100644 --- a/src/xml_shaper.zig +++ b/src/xml_shaper.zig @@ -96,14 +96,14 @@ pub fn parse(comptime T: type, source: []const u8, options: ParseOptions) !Parse fn parseInternal(comptime T: type, element: *xml.Element, options: ParseOptions) !T { switch (@typeInfo(T)) { - .Bool => { + .bool => { if (std.ascii.eqlIgnoreCase("true", element.children.items[0].CharData)) return true; if (std.ascii.eqlIgnoreCase("false", element.children.items[0].CharData)) return false; return error.UnexpectedToken; }, - .Float, .ComptimeFloat => { + .float, .comptime_float => { return std.fmt.parseFloat(T, element.children.items[0].CharData) catch |e| { if (log_parse_traces) { std.log.err( @@ -121,7 +121,7 @@ fn parseInternal(comptime T: type, element: *xml.Element, options: ParseOptions) return e; }; }, - .Int, .ComptimeInt => { + .int, .comptime_int => { // 2021-10-05T16:39:45.000Z return std.fmt.parseInt(T, element.children.items[0].CharData, 10) catch |e| { if (element.children.items[0].CharData[element.children.items[0].CharData.len - 1] == 'Z') { @@ -146,7 +146,7 @@ fn parseInternal(comptime T: type, element: *xml.Element, options: ParseOptions) return e; }; }, - .Optional => |optional_info| { + .optional => |optional_info| { if (element.children.items.len == 0) { // This is almost certainly incomplete. Empty strings? xsi:nil? return null; @@ -156,7 +156,7 @@ fn parseInternal(comptime T: type, element: *xml.Element, options: ParseOptions) return try parseInternal(optional_info.child, element, options); } }, - .Enum => |enum_info| { + .@"enum" => |enum_info| { _ = enum_info; // const numeric: ?enum_info.tag_type = std.fmt.parseInt(enum_info.tag_type, element.children.items[0].CharData, 10) catch null; // if (numeric) |num| { @@ -166,7 +166,7 @@ fn parseInternal(comptime T: type, element: *xml.Element, options: ParseOptions) // return std.meta.stringToEnum(T, element.CharData); // } }, - .Union => |union_info| { + .@"union" => |union_info| { if (union_info.tag_type) |_| { // try each of the union fields until we find one that matches // inline for (union_info.fields) |u_field| { @@ -189,7 +189,7 @@ fn parseInternal(comptime T: type, element: *xml.Element, options: ParseOptions) } @compileError("Unable to parse into untagged union '" ++ @typeName(T) ++ "'"); }, - .Struct => |struct_info| { + .@"struct" => |struct_info| { var r: T = undefined; var fields_seen = [_]bool{false} ** struct_info.fields.len; var fields_set: u64 = 0; @@ -244,7 +244,7 @@ fn parseInternal(comptime T: type, element: *xml.Element, options: ParseOptions) fields_set = fields_set + 1; found_value = true; } - if (@typeInfo(field.type) == .Optional) { + if (@typeInfo(field.type) == .optional) { // Test "compiler assertion failure 2" // Zig compiler bug circa 0.9.0. Using "and !found_value" // in the if statement above will trigger assertion failure @@ -269,7 +269,7 @@ fn parseInternal(comptime T: type, element: *xml.Element, options: ParseOptions) return error.FieldElementMismatch; // see fields_seen for details return r; }, - .Array => //|array_info| { + .array => //|array_info| { return error.ArrayNotImplemented, // switch (token) { // .ArrayBegin => { @@ -304,7 +304,7 @@ fn parseInternal(comptime T: type, element: *xml.Element, options: ParseOptions) // else => return error.UnexpectedToken, // } // }, - .Pointer => |ptr_info| { + .pointer => |ptr_info| { const allocator = options.allocator orelse return error.AllocatorRequired; switch (ptr_info.size) { .One => {