tarry.singh/Radix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix several compileError calls introduced by recent changes; ensure Zig compiler catches errors at comptime.

Browse Source
This commit is contained in:
Tarry Singh 2023-07-17 09:10:27 +00:00
parent 0f9a92f27d
commit be8aa4fa8e
4 changed files with 31 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
stdx/meta.zig
View File

@ -110,11 +110,11 @@ pub fn asSlice(comptime T: type) type {
.One => switch (@typeInfo(info.child)) { .One => switch (@typeInfo(info.child)) {
// As Zig, convert pointer to Array as a slice. // As Zig, convert pointer to Array as a slice.
.Array => |arr_info| arr_info.child, .Array => |arr_info| arr_info.child,
else => compileError(err_msg), else => @compileError(err_msg),
}, },
else => compileError(err_msg), else => @compileError(err_msg),
}, },
else => compileError(err_msg), else => @compileError(err_msg),
}; };
} }
@ -146,7 +146,7 @@ pub fn TupleRangeX(comptime T: type, comptime start: usize, comptime end: usize)
} }
pub fn FnParam(comptime func: anytype, comptime n: comptime_int) type { pub fn FnParam(comptime func: anytype, comptime n: comptime_int) type {
return @typeInfo(@TypeOf(func)).Fn.params[n].type orelse compileError("anytype is not supported"); return @typeInfo(@TypeOf(func)).Fn.params[n].type orelse @compileError("anytype is not supported");
} }
pub fn FnArgs(comptime func: anytype) type { pub fn FnArgs(comptime func: anytype) type {

4
zml/aio.zig
View File

@ -526,7 +526,7 @@ pub fn loadBuffers(
if (@hasDecl(Model, "init")) { if (@hasDecl(Model, "init")) {
@call(.auto, Model.init, .{&model} ++ init_args); @call(.auto, Model.init, .{&model} ++ init_args);
} else { } else {
zml.meta.assertComptime(@TypeOf(init_args) == void or @TypeOf(init_args) == @TypeOf(.{}), "Model of type {} has no init function, so `loadBuffers` should be call with init_args set to {{}} (void)", .{Model}); stdx.debug.assertComptime(@TypeOf(init_args) == void or @TypeOf(init_args) == @TypeOf(.{}), "Model of type {} has no init function, so `loadBuffers` should be call with init_args set to {{}} (void)", .{Model});
} }
return loadModelBuffersWithPrefix(Model, model, buffer_store, allocator, platform, ""); return loadModelBuffersWithPrefix(Model, model, buffer_store, allocator, platform, "");
@ -623,7 +623,7 @@ fn visitStructAndLoadBuffer(allocator: std.mem.Allocator, prefix_builder: *Prefi
try visitStructAndLoadBuffer(allocator, prefix_builder, buffer_store, value, platform); try visitStructAndLoadBuffer(allocator, prefix_builder, buffer_store, value, platform);
} }
} else zml.meta.compileError("type not supported by visitStructAndLoadBuffer: {}", .{T}); } else stdx.debug.compileError("type not supported by visitStructAndLoadBuffer: {}", .{T});
}, },
.Array => { .Array => {
for (obj, 0..) |*value, i| { for (obj, 0..) |*value, i| {

30
zml/meta.zig
View File

@ -94,7 +94,7 @@ pub fn mapAlloc(comptime cb: anytype, allocator: std.mem.Allocator, ctx: FnParam
const type_info_to_ptr = @typeInfo(@TypeOf(to)); const type_info_to_ptr = @typeInfo(@TypeOf(to));
if (type_info_to_ptr != .Pointer) { if (type_info_to_ptr != .Pointer) {
stdx.debug.compileError("convertType is expecting a mutable `to` argument but received: " ++ @typeName(@TypeOf(to))); stdx.debug.compileError("convertType is expecting a mutable `to` argument but received: {}", .{@TypeOf(to)});
} }
const ToStruct = type_info_to_ptr.Pointer.child; const ToStruct = type_info_to_ptr.Pointer.child;
const type_info_to = @typeInfo(ToStruct); const type_info_to = @typeInfo(ToStruct);
@ -143,7 +143,7 @@ pub fn mapAlloc(comptime cb: anytype, allocator: std.mem.Allocator, ctx: FnParam
} else if (field.default_value) |_| { } else if (field.default_value) |_| {
@field(to, field.name) = null; @field(to, field.name) = null;
} else { } else {
stdx.meta.compileError("Mapping {} to {} failed. Missing field {s}", .{ FromStruct, ToStruct, field.name }); stdx.debug.compileError("Mapping {} to {} failed. Missing field {s}", .{ FromStruct, ToStruct, field.name });
}, },
else => @field(to, field.name) = @field(from, field.name), else => @field(to, field.name) = @field(from, field.name),
} }
@ -169,7 +169,7 @@ pub fn mapAlloc(comptime cb: anytype, allocator: std.mem.Allocator, ctx: FnParam
} }
to.* = items; to.* = items;
}, },
else => stdx.meta.compileError("zml.meta.mapAlloc doesn't support: " ++ @typeName(FromStruct)), else => stdx.debug.compileError("zml.meta.mapAlloc doesn't support: {}", .{FromStruct}),
}, },
.Optional => if (from) |f| { .Optional => if (from) |f| {
to.* = @as(@typeInfo(type_info_to_ptr.Pointer.child).Optional.child, undefined); to.* = @as(@typeInfo(type_info_to_ptr.Pointer.child).Optional.child, undefined);
@ -178,7 +178,7 @@ pub fn mapAlloc(comptime cb: anytype, allocator: std.mem.Allocator, ctx: FnParam
to.* = null; to.* = null;
}, },
.Int, .Float => to.* = from, .Int, .Float => to.* = from,
else => stdx.meta.compileError("zml.meta.mapAlloc doesn't support: " ++ @typeName(FromStruct)), else => stdx.debug.compileError("zml.meta.mapAlloc doesn't support: {}", .{FromStruct}),
} }
} }
@ -239,12 +239,12 @@ pub fn visit(comptime cb: anytype, ctx: FnParam(cb, 0), v: anytype) void {
const type_info_v = @typeInfo(T); const type_info_v = @typeInfo(T);
const K = switch (@typeInfo(FnParam(cb, 1))) { const K = switch (@typeInfo(FnParam(cb, 1))) {
.Pointer => |info| info.child, .Pointer => |info| info.child,
else => stdx.meta.compileError("zml.meta.visit is expecting a pointer value as second parameter in callback to use but found " ++ @typeName(FnParam(cb, 1))), else => stdx.debug.compileError("zml.meta.visit is expecting a pointer value as second parameter in callback to use but found {}", .{FnParam(cb, 1)}),
}; };
if (type_info_v != .Pointer) { if (type_info_v != .Pointer) {
const Callback = @TypeOf(cb); const Callback = @TypeOf(cb);
stdx.meta.compileError("zml.meta.visit is expecting a pointer input to go with following callback signature: " ++ @typeName(Callback) ++ " but received: " ++ @typeName(T)); stdx.debug.compileError("zml.meta.visit is expecting a pointer input to go with following callback signature: {} but received: {}", .{ Callback, T });
} }
const ptr_info = type_info_v.Pointer; const ptr_info = type_info_v.Pointer;
if (@typeInfo(ptr_info.child) == .Fn) return; if (@typeInfo(ptr_info.child) == .Fn) return;
@ -307,7 +307,7 @@ pub fn visit(comptime cb: anytype, ctx: FnParam(cb, 0), v: anytype) void {
} }
} }
}, },
else => stdx.meta.compileError("Only single pointer and slice are supported. Received " ++ @typeName(T)), else => stdx.debug.compileError("Only single pointer and slice are supported. Received {}", .{T}),
} }
} }
@ -320,9 +320,7 @@ test visit {
const MultipleTypesStruct = struct { prop1: Attr, prop2: OtherAttr, prop3: ?Attr }; const MultipleTypesStruct = struct { prop1: Attr, prop2: OtherAttr, prop3: ?Attr };
const NestedTypesStruct = struct { prop1: Attr, prop2: OtherAttr, prop3: NestedAttr, prop4: NestedAttrOptional }; const NestedTypesStruct = struct { prop1: Attr, prop2: OtherAttr, prop3: NestedAttr, prop4: NestedAttrOptional };
const LocalContext = struct { const LocalContext = struct { result: usize };
result: usize,
};
{ {
var context: LocalContext = .{ .result = 0 }; var context: LocalContext = .{ .result = 0 };
@ -406,13 +404,13 @@ pub fn zip(comptime func: anytype, allocator: std.mem.Allocator, values: anytype
// const fn_args // const fn_args
return switch (@typeInfo(V)) { return switch (@typeInfo(V)) {
.Pointer => stdx.meta.compileError("zip only accept by value arguments. Received: " ++ @typeName(V)), .Pointer => stdx.debug.compileError("zip only accept by value arguments. Received: {}", .{V}),
.Struct => |struct_info| { .Struct => |struct_info| {
var out: V = values[0]; var out: V = values[0];
inline for (struct_info.fields) |f| { inline for (struct_info.fields) |f| {
if (f.is_comptime) continue; if (f.is_comptime) continue;
if (@typeInfo(f.type) == .Pointer) { if (@typeInfo(f.type) == .Pointer) {
stdx.meta.compileError("zip doesn't follow pointers and don't accept struct containing them. Received: " ++ @typeName(V)); stdx.debug.compileError("zip doesn't follow pointers and don't accept struct containing them. Received: {}", .{V});
} }
var fields = try allocator.alloc(f.type, values.len); var fields = try allocator.alloc(f.type, values.len);
defer allocator.free(fields); defer allocator.free(fields);
@ -425,7 +423,7 @@ pub fn zip(comptime func: anytype, allocator: std.mem.Allocator, values: anytype
}, },
.Array => |arr_info| { .Array => |arr_info| {
if (@typeInfo(arr_info.child) == .Pointer) { if (@typeInfo(arr_info.child) == .Pointer) {
stdx.meta.compileError("zip doesn't follow pointers and don't accept struct containing them. Received: " ++ @typeName(V)); stdx.debug.compileError("zip doesn't follow pointers and don't accept struct containing them. Received: {}", .{V});
} }
var out: V = undefined; var out: V = undefined;
var slice = try allocator.alloc(arr_info.child, values.len); var slice = try allocator.alloc(arr_info.child, values.len);
@ -438,7 +436,7 @@ pub fn zip(comptime func: anytype, allocator: std.mem.Allocator, values: anytype
} }
return out; return out;
}, },
.Union, .Optional => stdx.meta.compileError("zip doesn't yet support " ++ @typeName(V)), .Union, .Optional => stdx.debug.compileError("zip doesn't yet support {}", .{V}),
else => values[0], else => values[0],
}; };
} }
@ -484,10 +482,10 @@ pub fn collect(func: anytype, func_ctx: _CollectCtx(func), out: *std.ArrayList(s
fn _CollectCtx(func: anytype) type { fn _CollectCtx(func: anytype) type {
const params = @typeInfo(@TypeOf(func)).Fn.params; const params = @typeInfo(@TypeOf(func)).Fn.params;
if (params.len == 1) return void; if (params.len == 1) return void;
return params[0].type orelse stdx.meta.compileError("anytype not supported in collect"); return params[0].type orelse @compileError("anytype not supported in collect");
} }
fn _CollectArg(func: anytype) type { fn _CollectArg(func: anytype) type {
const params = @typeInfo(@TypeOf(func)).Fn.params; const params = @typeInfo(@TypeOf(func)).Fn.params;
return params[params.len - 1].type orelse stdx.meta.compileError("anytype not supported in collect"); return params[params.len - 1].type orelse @compileError("anytype not supported in collect");
} }

22
zml/shape.zig
View File

@ -60,7 +60,7 @@ pub const Shape = struct {
} else if (comptime isAutoDim(fv)) { } else if (comptime isAutoDim(fv)) {
dims_.appendAssumeCapacity(-1); dims_.appendAssumeCapacity(-1);
} else { } else {
stdx.meta.compileError("Field {s} should be an integer or an auto dimension", .{field.name}); stdx.debug.compileError("Field {s} should be an integer or an auto dimension", .{field.name});
} }
if (comptime stdx.meta.isTuple(T)) { if (comptime stdx.meta.isTuple(T)) {
tags_.appendAssumeCapacity(TagUnknown); tags_.appendAssumeCapacity(TagUnknown);
@ -72,7 +72,7 @@ pub const Shape = struct {
return .{ dims_, tags_ }; return .{ dims_, tags_ };
} }
stdx.meta.compileError("expected a dimension tuple eg '.{{ .a = 10, .b = 20}}' or '.{{ 10, 20 }}', got {}", .{T}); stdx.debug.compileError("expected a dimension tuple eg '.{{ .a = 10, .b = 20}}' or '.{{ 10, 20 }}', got {}", .{T});
} }
test parseDimensions { test parseDimensions {
@ -109,7 +109,7 @@ pub const Shape = struct {
return .{ axes_, tags_ }; return .{ axes_, tags_ };
} }
stdx.meta.compileError("Wrong type, got {}. Expected .{{.a, .b}}", .{T}); stdx.debug.compileError("Wrong type, got {}. Expected .{{.a, .b}}", .{T});
} }
pub fn parseTags(v: anytype) TagsArray { pub fn parseTags(v: anytype) TagsArray {
@ -181,7 +181,7 @@ pub const Shape = struct {
EnumLiteral => @tagName(v).ptr, EnumLiteral => @tagName(v).ptr,
std.builtin.Type.StructField => v.name.ptr, std.builtin.Type.StructField => v.name.ptr,
Tag => v, Tag => v,
else => stdx.meta.compileError("Value should be an EnumLiteral, a Shape.Tag or a StructField, got {}", .{T}), else => stdx.debug.compileError("Value should be an EnumLiteral, a Shape.Tag or a StructField, got {}", .{T}),
}; };
} }
@ -239,7 +239,7 @@ pub const Shape = struct {
return true; return true;
} }
stdx.meta.compileError("Expected tuple of tags, got {any}", .{T}); stdx.debug.compileError("Expected tuple of tags, got {any}", .{T});
} }
pub fn isFullyTagged(self: Shape) bool { pub fn isFullyTagged(self: Shape) bool {
@ -261,7 +261,7 @@ pub const Shape = struct {
return self.axisFromTag(toTag(axis_)); return self.axisFromTag(toTag(axis_));
} }
stdx.meta.compileError("Wrong axis type, expected .literal, or an integer, got: {any}", .{T}); stdx.debug.compileError("Wrong axis type, expected .literal, or an integer, got: {any}", .{T});
} }
pub fn axes(self: Shape, axes_: anytype) AxesArray { pub fn axes(self: Shape, axes_: anytype) AxesArray {
@ -289,7 +289,7 @@ pub const Shape = struct {
return res; return res;
} }
stdx.meta.compileError("axes expects an int-tuple or a tuple of enum literal, got {}", .{T}); stdx.debug.compileError("axes expects an int-tuple or a tuple of enum literal, got {}", .{T});
} }
fn axisFromInt(self: Shape, d: isize) u3 { fn axisFromInt(self: Shape, d: isize) u3 {
@ -590,7 +590,7 @@ pub const Shape = struct {
return res; return res;
} }
stdx.meta.compileError("Expected a tuple of enum literals eg: .{ .a, .b, .c } got: {any}", .{@TypeOf(tagz)}); stdx.debug.compileError("Expected a tuple of enum literals eg: .{ .a, .b, .c } got: {any}", .{@TypeOf(tagz)});
} }
test withTags { test withTags {
@ -637,7 +637,7 @@ pub const Shape = struct {
return res; return res;
} }
stdx.meta.compileError("Expected a tuple of enum literals eg: .{ .a, .b, .c } got: {any}", .{@TypeOf(tagz)}); stdx.debug.compileError("Expected a tuple of enum literals eg: .{ .a, .b, .c } got: {any}", .{@TypeOf(tagz)});
} }
test withPartialTags { test withPartialTags {
@ -934,7 +934,7 @@ pub const Shape = struct {
return .{ vals_, tags_ }; return .{ vals_, tags_ };
} }
stdx.meta.compileError("parseStruct expects struct or tuple, got {}", .{V}); stdx.debug.compileError("parseStruct expects struct or tuple, got {}", .{V});
} }
test parseStruct { test parseStruct {
@ -967,7 +967,7 @@ pub const Shape = struct {
return res; return res;
} }
stdx.meta.compileError("parseStruct expects struct or tuple, got {}", .{V}); stdx.debug.compileError("parseStruct expects struct or tuple, got {}", .{V});
} }
test parseAxesOptions { test parseAxesOptions {