Fix vector and quaternion tostring() by not using %.6g

Whoops, didn't realize that number referred to the number of significant
digits. Use `%.6f` and manual trailing zero trimming instead.

Author: HaroldCindy

VM/src/cjson/lua_cjson.cpp

@@ -863,9 +863,10 @@ static void json_append_number(lua_State *l, json_config_t *cfg,
 static void json_append_coordinate_component(lua_State *l, strbuf_t *json, float val, bool tight = false) {
     if (tight && val == 0.0f)
         return;  // Omit zeros in tight mode
-    char format_buf[64] = {};
+    char format_buf[256] = {};
     // Use shared helper to ensure consistent normalization of non-finite values
-    size_t str_len = luai_formatfloat(format_buf, sizeof(format_buf), "%.6g", val);
+    size_t str_len = luai_formatfloat(format_buf, sizeof(format_buf), "%.6f", val);
+    str_len = luai_trimfloat(format_buf, str_len);
     strbuf_append_mem(json, format_buf, str_len);
 }
 

VM/src/llsl.cpp

@@ -1029,19 +1029,23 @@ static int lsl_tostring_quat(lua_State *L)
     if (a == nullptr)
         luaL_typeerror(L, 1, "quaternion");
 
-    char buf[128] = {};
+    char buf[256] = {};
     char* p = buf;
     *p++ = '<';
 
-    const char* format = LUAU_IS_LSL_VM(L) ? "%5.5f" : "%.6g";
+    bool is_lsl = LUAU_IS_LSL_VM(L);
+    const char* format = is_lsl ? "%5.5f" : "%.6f";
     for (int i = 0; i < 4; i++)
     {
         if (i > 0)
         {
             *p++ = ',';
             *p++ = ' ';
         }
-        p += luai_formatfloat(p, buf + sizeof(buf) - p, format, a[i]);
+        int n = luai_formatfloat(p, buf + sizeof(buf) - p, format, a[i]);
+        if (!is_lsl)
+            n = luai_trimfloat(p, n);
+        p += n;
     }
 
     *p++ = '>';

VM/src/lnumprint.cpp

@@ -370,10 +370,30 @@ char* luai_num2str(char* buf, double n)
     }
 }
 
+// ServerLua: Strip trailing zeros and bare decimal point from formatted float
+int luai_trimfloat(char* buf, int len)
+{
+    if (len <= 0)
+        return len;
+
+    // If there is a decimal within buf and buf + len
+    if (memchr(buf, '.', len))
+    {
+        // Trim trailing zeros
+        while (len > 0 && buf[len - 1] == '0')
+            len--;
+        // If we're left with nothing after the decimal then trim the decimal
+        if (len > 0 && buf[len - 1] == '.')
+            len--;
+    }
+    return len;
+}
+
 // ServerLua: Format a float with normalized non-finite values for LSL semantics
 int luai_formatfloat(char* buf, size_t bufsize, const char* format, float value)
 {
-    LUAU_ASSERT(bufsize >= 20);
+    // We need enough space to fit the max magnitude float with 6 decimals
+    LUAU_ASSERT(bufsize >= 60);
 
     if (isnan(value))
     {

VM/src/lnumutils.h

@@ -123,5 +123,6 @@ LUAI_FUNC char* luai_num2str(char* buf, double n);
 // This ensures consistent LSL semantics for vector/quaternion toString and JSON serialization.
 // Requires bufsize >= 20 and pre-zeroed buffer.
 LUAI_FUNC int luai_formatfloat(char* buf, size_t bufsize, const char* format, float value);
+LUAI_FUNC int luai_trimfloat(char* buf, int len);
 
 #define luai_str2num(s, p) strtod((s), (p))

VM/src/lveclib.cpp

@@ -355,19 +355,23 @@ static int vector_tostring(lua_State *L)
 {
     auto* a = luaL_checkvector(L, 1);
 
-    char buf[128] = {};
+    char buf[256] = {};
     char* p = buf;
     *p++ = '<';
 
-    const char* format = LUAU_IS_LSL_VM(L) ? "%5.5f" : "%.6g";
+    bool is_lsl = LUAU_IS_LSL_VM(L);
+    const char* format = is_lsl ? "%5.5f" : "%.6f";
     for (int i = 0; i < 3; i++)
     {
         if (i > 0)
         {
             *p++ = ',';
             *p++ = ' ';
         }
-        p += luai_formatfloat(p, buf + sizeof(buf) - p, format, a[i]);
+        int n = luai_formatfloat(p, buf + sizeof(buf) - p, format, a[i]);
+        if (!is_lsl)
+            n = luai_trimfloat(p, n);
+        p += n;
     }
 
     *p++ = '>';

tests/conformance/lljson.lua

@@ -22,8 +22,8 @@ assert(lljson.encode({foo="bar"}) == '{"foo":"bar"}')
 assert(lljson.encode({foo=nil}) == '{}')
 -- But we can represent it explicitly with `lljson.null`
 assert(lljson.encode({foo=lljson.null}) == '{"foo":null}')
-assert(lljson.encode(vector(1, 2.5, 22.0 / 7.0)) == '"<1,2.5,3.14286>"')
-assert(lljson.encode(quaternion(1, 2.5, 22.0 / 7.0, 4)) == '"<1,2.5,3.14286,4>"')
+assert(lljson.encode(vector(1, 2.5, 22.0 / 7.0)) == '"<1,2.5,3.142857>"')
+assert(lljson.encode(quaternion(1, 2.5, 22.0 / 7.0, 4)) == '"<1,2.5,3.142857,4>"')
 
 -- metatables are totally ignored
 local SomeMT = {}

tests/conformance/quaternion.lua

@@ -28,6 +28,11 @@ assert(`{quaternion.tofwd(yaw_ninety)}` == "<0, 1, 0>")
 assert(`{quaternion.toleft(yaw_ninety)}` == "<-1, 0, 0>")
 assert(`{quaternion.toup(yaw_ninety)}` == "<0, 0, 1>")
 
+-- Test that tostring doesn't lose precision for large component values
+assert(`{vector(123456.5, 0, 0)}` == "<123456.5, 0, 0>")
+assert(`{vector(1000001, 0, 0)}` == "<1000001, 0, 0>")
+assert(`{quaternion(123456.5, 0, 0, 1)}` == "<123456.5, 0, 0, 1>")
+
 -- Check rotation module has same implementation as quaternion module
 for k,_ in quaternion do
     assert(rotation[k] ~= nil)