Resolves some review feedback

Author: MasonRemaley

lib/std/math/big/int.zig

@@ -2225,25 +2225,20 @@ pub const Const = struct {
 
     /// Convert self to float type T.
     pub fn toFloat(self: Const, comptime T: type) T {
-        switch (@typeInfo(T)) {
-            .float => {
-                if (self.limbs.len == 0) return 0;
-
-                const base = std.math.maxInt(std.math.big.Limb) + 1;
-                var result: f128 = 0;
-                var i: usize = self.limbs.len;
-                while (i != 0) {
-                    i -= 1;
-                    const limb: f128 = @floatFromInt(self.limbs[i]);
-                    result = @mulAdd(f128, base, result, limb);
-                }
-                if (self.positive) {
-                    return @floatCast(result);
-                } else {
-                    return @floatCast(-result);
-                }
-            },
-            else => @compileError("expected float type, found '" ++ @typeName(T) ++ "'"),
+        if (self.limbs.len == 0) return 0;
+
+        const base = std.math.maxInt(std.math.big.Limb) + 1;
+        var result: f128 = 0;
+        var i: usize = self.limbs.len;
+        while (i != 0) {
+            i -= 1;
+            const limb: f128 = @floatFromInt(self.limbs[i]);
+            result = @mulAdd(f128, base, result, limb);
+        }
+        if (self.positive) {
+            return @floatCast(result);
+        } else {
+            return @floatCast(-result);
         }
     }
 

lib/std/std.zig

@@ -44,7 +44,6 @@ pub const Thread = @import("Thread.zig");
 pub const Treap = @import("treap.zig").Treap;
 pub const Tz = tz.Tz;
 pub const Uri = @import("Uri.zig");
-pub const zon = @import("zon.zig");
 
 pub const array_hash_map = @import("array_hash_map.zig");
 pub const atomic = @import("atomic.zig");
@@ -94,6 +93,7 @@ pub const valgrind = @import("valgrind.zig");
 pub const wasm = @import("wasm.zig");
 pub const zig = @import("zig.zig");
 pub const zip = @import("zip.zig");
+pub const zon = @import("zon.zig");
 pub const start = @import("start.zig");
 
 const root = @import("root");

lib/std/zig/AstGen.zig

@@ -11526,7 +11526,7 @@ fn failWithStrLitError(
     offset: u32,
 ) InnerError {
     const raw_string = bytes[offset..];
-    return AstGen.failOff(
+    return failOff(
         astgen,
         token,
         @intCast(offset + err.offset()),

lib/std/zig/Zir.zig

@@ -481,7 +481,7 @@ pub const Inst = struct {
         /// Uses the `pl_node` union field. `payload_index` points to a `FuncFancy`.
         func_fancy,
         /// Implements the `@import` builtin.
-        /// Uses the `str_tok` field.
+        /// Uses the `pl_tok` field.
         import,
         /// Integer literal that fits in a u64. Uses the `int` union field.
         int,

lib/std/zig/ZonGen.zig

@@ -270,7 +270,6 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator
             if (size == 0) {
                 try zg.addErrorNodeNotes(node, "void literals are not available in ZON", .{}, &.{
                     try zg.errNoteNode(node, "void union payloads can be represented by enum literals", .{}),
-                    try zg.errNoteNode(node, "for example, `.{{ .foo = {{}} }}` becomes `.foo`", .{}),
                 });
             } else {
                 try zg.addErrorNode(node, "blocks are not allowed in ZON", .{});

lib/std/zig/number_literal.zig

@@ -60,11 +60,6 @@ pub const Error = union(enum) {
     period_after_exponent: usize,
 };
 
-const FormatWithSource = struct {
-    bytes: []const u8,
-    err: Error,
-};
-
 /// Parse Zig number literal accepted by fmt.parseInt, fmt.parseFloat and big_int.setString.
 /// Valid for any input.
 pub fn parseNumberLiteral(bytes: []const u8) Result {

lib/std/zon.zig

@@ -17,7 +17,7 @@
 //! * anonymous tuple literals
 //!
 //! Here is an example ZON object:
-//! ```zon
+//! ```
 //! .{
 //!     .a = 1.5,
 //!     .b = "hello, world!",
@@ -27,7 +27,7 @@
 //! ```
 //!
 //! Individual primitives are also valid ZON, for example:
-//! ```zon
+//! ```
 //! "This string is a valid ZON object."
 //! ```
 //!

src/Compilation.zig

@@ -3521,6 +3521,7 @@ pub fn addZirErrorMessages(eb: *ErrorBundle.Wip, file: *Zcu.File) !void {
 
 pub fn addZoirErrorMessages(eb: *ErrorBundle.Wip, file: *Zcu.File) !void {
     assert(file.source_loaded);
+    assert(file.tree_loaded);
     const gpa = eb.gpa;
     const src_path = try file.fullPath(gpa);
     defer gpa.free(src_path);

src/Sema.zig

@@ -14453,12 +14453,12 @@ fn zirImport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
             };
 
             if (extra.res_ty == .none) {
-                return sema.fail(block, operand_src, "import ZON must have a known result type", .{});
+                return sema.fail(block, operand_src, "'@import' of ZON must have a known result type", .{});
             }
             const res_ty_inst = try sema.resolveInst(extra.res_ty);
             const res_ty = try sema.analyzeAsType(block, operand_src, res_ty_inst);
             if (res_ty.isGenericPoison()) {
-                return sema.fail(block, operand_src, "import ZON must have a known result type", .{});
+                return sema.fail(block, operand_src, "'@import' of ZON must have a known result type", .{});
             }
 
             const interned = try zon.lower(

src/zon.zig

@@ -71,18 +71,6 @@ fn fail(
     return self.sema.failWithOwnedErrorMsg(self.block, err_msg);
 }
 
-const Ident = struct {
-    bytes: []const u8,
-    owned: bool,
-
-    fn deinit(self: *Ident, allocator: Allocator) void {
-        if (self.owned) {
-            allocator.free(self.bytes);
-        }
-        self.* = undefined;
-    }
-};
-
 fn lowerExpr(self: LowerZon, node: Zoir.Node.Index, res_ty: Type) CompileError!InternPool.Index {
     switch (Type.zigTypeTag(res_ty, self.sema.pt.zcu)) {
         .bool => return self.lowerBool(node),
@@ -502,7 +490,7 @@ fn lowerTuple(self: LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool.I
     const field_defaults = tuple_info.values.get(ip);
     const field_types = tuple_info.types.get(ip);
     const elems = try self.sema.arena.alloc(InternPool.Index, field_types.len);
-    for (elems) |*v| v.* = .none;
+    @memset(elems, .none);
 
     for (0..elem_nodes.len) |i| {
         if (i >= elems.len) {
@@ -570,7 +558,7 @@ fn lowerStruct(self: LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool.
 
     const field_defaults = struct_info.field_inits.get(ip);
     const field_values = try self.sema.arena.alloc(InternPool.Index, struct_info.field_names.len);
-    for (field_values) |*v| v.* = .none;
+    @memset(field_values, .none);
 
     for (0..fields.names.len) |i| {
         const field_name = try ip.getOrPutString(
@@ -627,7 +615,7 @@ fn lowerStruct(self: LowerZon, node: Zoir.Node.Index, res_ty: Type) !InternPool.
     for (field_values, field_names) |*value, name| {
         if (value.* == .none) return self.fail(
             .{ .node_abs = node.getAstNode(self.file.zoir.?) },
-            "missing field {}",
+            "missing field '{}'",
             .{name.fmt(ip)},
         );
     }