Merge branch 'main' into ben/delete-meta-functions

src/bun.zig

@@ -4064,7 +4064,7 @@ pub fn Once(comptime f: anytype) type {
 /// `val` must be a pointer to an optional type (e.g. `*?T`)
 ///
 /// This function takes the value out of the optional, replacing it with null, and returns the value.
-pub inline fn take(val: anytype) ?bun.meta.OptionalChild(@TypeOf(val)) {
+pub inline fn take(val: anytype) ?@TypeOf(val.*.?) {
     if (val.*) |v| {
         val.* = null;
         return v;

src/css/values/color.zig

@@ -2061,8 +2061,7 @@ pub const ComponentParser = struct {
             return this.parseFrom(from, input, T, C, func, args_);
         }
 
-        const args = bun.meta.ConcatArgs2(func, input, this, args_);
-        return @call(.auto, func, args);
+        return @call(.auto, func, .{ input, this } ++ args_);
     }
 
     pub fn parseFrom(
@@ -2092,8 +2091,7 @@ pub const ComponentParser = struct {
 
         this.from = RelativeComponentParser.new(&new_from);
 
-        const args = bun.meta.ConcatArgs2(func, input, this, args_);
-        return @call(.auto, func, args);
+        return @call(.auto, func, .{ input, this } ++ args_);
     }
 
     pub fn parseNumberOrPercentage(this: *const ComponentParser, input: *css.Parser) Result(NumberOrPercentage) {

src/meta.zig

@@ -3,14 +3,6 @@ const bun = @import("root").bun;
 
 pub usingnamespace std.meta;
 
-pub fn OptionalChild(comptime T: type) type {
-    const tyinfo = @typeInfo(T);
-    if (tyinfo != .Pointer) @compileError("OptionalChild(T) requires that T be a pointer to an optional type.");
-    const child = @typeInfo(tyinfo.Pointer.child);
-    if (child != .Optional) @compileError("OptionalChild(T) requires that T be a pointer to an optional type.");
-    return child.Optional.child;
-}
-
 pub fn EnumFields(comptime T: type) []const std.builtin.Type.EnumField {
     const tyinfo = @typeInfo(T);
     return switch (tyinfo) {
@@ -22,30 +14,6 @@ pub fn EnumFields(comptime T: type) []const std.builtin.Type.EnumField {
     };
 }
 
-pub fn ReturnOfMaybe(comptime function: anytype) type {
-    const Func = @TypeOf(function);
-    const typeinfo: std.builtin.Type.Fn = @typeInfo(Func).Fn;
-    const MaybeType = typeinfo.return_type orelse @compileError("Expected the function to have a return type");
-    return MaybeResult(MaybeType);
-}
-
-pub fn MaybeResult(comptime MaybeType: type) type {
-    const maybe_ty_info = @typeInfo(MaybeType);
-
-    const maybe = maybe_ty_info.Union;
-    if (maybe.fields.len != 2) @compileError("Expected the Maybe type to be a union(enum) with two variants");
-
-    if (!std.mem.eql(u8, maybe.fields[0].name, "err")) {
-        @compileError("Expected the first field of the Maybe type to be \"err\", got: " ++ maybe.fields[0].name);
-    }
-
-    if (!std.mem.eql(u8, maybe.fields[1].name, "result")) {
-        @compileError("Expected the second field of the Maybe type to be \"result\"" ++ maybe.fields[1].name);
-    }
-
-    return maybe.fields[1].type;
-}
-
 pub fn ReturnOf(comptime function: anytype) type {
     return ReturnOfType(@TypeOf(function));
 }
@@ -118,127 +86,6 @@ pub fn Item(comptime T: type) type {
     }
 }
 
-/// Returns .{a, ...args_}
-pub fn ConcatArgs1(
-    comptime func: anytype,
-    a: anytype,
-    args_: anytype,
-) std.meta.ArgsTuple(@TypeOf(func)) {
-    var args: std.meta.ArgsTuple(@TypeOf(func)) = undefined;
-    args[0] = a;
-
-    inline for (args_, 1..) |arg, i| {
-        args[i] = arg;
-    }
-
-    return args;
-}
-
-/// Returns .{a, b, ...args_}
-pub inline fn ConcatArgs2(
-    comptime func: anytype,
-    a: anytype,
-    b: anytype,
-    args_: anytype,
-) std.meta.ArgsTuple(@TypeOf(func)) {
-    var args: std.meta.ArgsTuple(@TypeOf(func)) = undefined;
-    args[0] = a;
-    args[1] = b;
-
-    inline for (args_, 2..) |arg, i| {
-        args[i] = arg;
-    }
-
-    return args;
-}
-
-/// Returns .{a, b, c, d, ...args_}
-pub inline fn ConcatArgs4(
-    comptime func: anytype,
-    a: anytype,
-    b: anytype,
-    c: anytype,
-    d: anytype,
-    args_: anytype,
-) std.meta.ArgsTuple(@TypeOf(func)) {
-    var args: std.meta.ArgsTuple(@TypeOf(func)) = undefined;
-    args[0] = a;
-    args[1] = b;
-    args[2] = c;
-    args[3] = d;
-
-    inline for (args_, 4..) |arg, i| {
-        args[i] = arg;
-    }
-
-    return args;
-}
-
-// Copied from std.meta
-fn CreateUniqueTuple(comptime N: comptime_int, comptime types: [N]type) type {
-    var tuple_fields: [types.len]std.builtin.Type.StructField = undefined;
-    inline for (types, 0..) |T, i| {
-        @setEvalBranchQuota(10_000);
-        var num_buf: [128]u8 = undefined;
-        tuple_fields[i] = .{
-            .name = std.fmt.bufPrintZ(&num_buf, "{d}", .{i}) catch unreachable,
-            .type = T,
-            .default_value = null,
-            .is_comptime = false,
-            .alignment = if (@sizeOf(T) > 0) @alignOf(T) else 0,
-        };
-    }
-
-    return @Type(.{
-        .Struct = .{
-            .is_tuple = true,
-            .layout = .auto,
-            .decls = &.{},
-            .fields = &tuple_fields,
-        },
-    });
-}
-
-pub fn hasStableMemoryLayout(comptime T: type) bool {
-    const tyinfo = @typeInfo(T);
-    return switch (tyinfo) {
-        .Type => true,
-        .Void => true,
-        .Bool => true,
-        .Int => true,
-        .Float => true,
-        .Enum => {
-            // not supporting this rn
-            if (tyinfo.Enum.is_exhaustive) return false;
-            return hasStableMemoryLayout(tyinfo.Enum.tag_type);
-        },
-        .Struct => switch (tyinfo.Struct.layout) {
-            .auto => {
-                inline for (tyinfo.Struct.fields) |field| {
-                    if (!hasStableMemoryLayout(field.field_type)) return false;
-                }
-                return true;
-            },
-            .@"extern" => true,
-            .@"packed" => false,
-        },
-        .Union => switch (tyinfo.Union.layout) {
-            .auto => {
-                if (tyinfo.Union.tag_type == null or !hasStableMemoryLayout(tyinfo.Union.tag_type.?)) return false;
-
-                inline for (tyinfo.Union.fields) |field| {
-                    if (!hasStableMemoryLayout(field.type)) return false;
-                }
-
-                return true;
-            },
-            .@"extern" => true,
-            .@"packed" => false,
-        },
-        else => true,
-    };
-}
-
 pub fn isSimpleCopyType(comptime T: type) bool {
     const tyinfo = @typeInfo(T);
     return switch (tyinfo) {
@@ -264,17 +111,6 @@ pub fn isSimpleCopyType(comptime T: type) bool {
     };
 }
 
-pub fn isScalar(comptime T: type) bool {
-    return switch (T) {
-        i32, u32, i64, u64, f32, f64, bool => true,
-        else => {
-            const tyinfo = @typeInfo(T);
-            if (tyinfo == .Enum) return true;
-            return false;
-        },
-    };
-}
-
 pub fn isSimpleEqlType(comptime T: type) bool {
     const tyinfo = @typeInfo(T);
     return switch (tyinfo) {