Precision overrides 0-padding in #fmt

1 files changed, 49 insertions, 34 deletions

diff --git a/src/lib/ExtFmt.rs b/src/lib/ExtFmt.rs
index 79f86038..64157cda 100644
--- a/src/lib/ExtFmt.rs
+++ b/src/lib/ExtFmt.rs
@@ -451,13 +451,13 @@ mod RT {
         ret _str.unsafe_from_bytes(svec);
     }
 
-    tag pad_type {
+    tag pad_mode {
         pad_signed;
         pad_unsigned;
         pad_nozero;
     }
 
-    fn pad(&conv cv, str s, pad_type pt) -> str {
+    fn pad(&conv cv, str s, pad_mode mode) -> str {
         auto uwidth;
         alt (cv.width) {
             case (count_implied) {
@@ -479,44 +479,59 @@ mod RT {
         if (have_flag(cv.flags, flag_left_justify)) {
             auto padstr = str_init_elt(padchar, diff);
             ret s + padstr;
-        } else {
-            auto zero_padding = false;
-            auto signed = false;
-            alt (pt) {
-                case (pad_nozero) {
-                    // fallthrough
-                }
-                case (pad_signed) {
-                    signed = true;
-                    if (have_flag(cv.flags, flag_left_zero_pad)) {
-                        padchar = '0';
-                        zero_padding = true;
-                    }
+        }
+
+        auto might_zero_pad = false;
+        auto signed = false;
+
+        alt (mode) {
+            case (pad_nozero) {
+                // fallthrough
+            }
+            case (pad_signed) {
+                might_zero_pad = true;
+                signed = true;
+            }
+            case (pad_unsigned) {
+                might_zero_pad = true;
+            }
+        }
+
+        fn have_precision(&conv cv) -> bool {
+            alt (cv.precision) {
+                case (count_implied) {
+                    ret false;
                 }
-                case (pad_unsigned) {
-                    if (have_flag(cv.flags, flag_left_zero_pad)) {
-                        padchar = '0';
-                        zero_padding = true;
-                    }
+                case (_) {
+                    ret true;
                 }
             }
+        }
 
-            auto padstr = str_init_elt(padchar, diff);
+        auto zero_padding = false;
+        if (might_zero_pad
+            && have_flag(cv.flags, flag_left_zero_pad)
+            && !have_precision(cv)) {
 
-            // This is completely heinous. If we have a signed value then
-            // potentially rip apart the intermediate result and insert some
-            // zeros. It may make sense to convert zero padding to a precision
-            // instead.
-            if (signed
-                && zero_padding
-                && _str.byte_len(s) > 0u
-                && s.(0) == '-' as u8) {
-
-                auto bytelen = _str.byte_len(s);
-                auto numpart = _str.substr(s, 1u, bytelen - 1u);
-                ret "-" + padstr + numpart;
-            }
+            padchar = '0';
+            zero_padding = true;
+        }
+
+        auto padstr = str_init_elt(padchar, diff);
 
+        // This is completely heinous. If we have a signed value then
+        // potentially rip apart the intermediate result and insert some
+        // zeros. It may make sense to convert zero padding to a precision
+        // instead.
+        if (signed
+            && zero_padding
+            && _str.byte_len(s) > 0u
+            && s.(0) == '-' as u8) {
+
+            auto bytelen = _str.byte_len(s);
+            auto numpart = _str.substr(s, 1u, bytelen - 1u);
+            ret "-" + padstr + numpart;
+        } else {
             ret padstr + s;
         }
     }