Implementations of formatting traits for signed integers can be ambiguous

[Enet4]

I was recently formatting a signed integer primitive to hexadecimal using the standard formatter API, hoping that the result would be aware of the value's sign. It turns out that the implementations of UpperHex (and relatives such as LowerHex and Binary) for signed integers simply treat these numbers as unsigned (or just a sequence of bits).

println!("{:X}", -15i32);   // prints "FFFFFFF1",   expected "-F"

I posted this concern first as an SO question. A way around this is to make a newtype with another formatting implementation.

I can make arguments on both sides whether it should (or not) behave like this, but what actually concerns me most is that there seems to be no mention of this behaviour in the documentation. It appears that formatting trait implementations do not have to abide to a value's sign, but then the fact that a negative integer is treated as an unsigned number for formatting purposes can be unexpected for some people, especially when the docs do not clarify this situation.

To sum up: should we improve the documentation regarding what makes a valid formatting trait implementation? Should we also (or just) document further their implementations for integers in particular? I am willing to collaborate with the necessary changes one we're clear about what should be improved.

[dtolnay]

This representation dates back to #1653 which implemented UpperHex using *self as $unsigned in 6feb58e.

For what it's worth, iostream in C++ and printf in C both handle this the same way we do.

#include <iostream>

int main() {
  int32_t x = -15;
  std::cout << std::uppercase << std::hex << x << '\n';
}

#include <stdint.h>
#include <stdio.h>

int main(void) {
  int32_t x = -15;
  printf("%X\n", x);
}

I don't believe we need to change the behavior but I do agree that the expectations around implementation of UpperHex and friends needs to be documented better.

[Stargateur]

Your code in C invoke undefined behavior, printf() family expect an unsigned int when you use the specifier X. If you don't send the right type to printf() the behavior is undefined. Plus, you use int32_t where an uint32_t will be undefined too.

[dtolnay]

Thanks @Stargateur. What would be the defined way to print a signed 32-bit integer in uppercase hex?

[Stargateur]

There are no way,

7.8.1 Macros for format specifiers (C11)
...
2 The fprintf macros for signed integers are:
PRIdN PRIdLEASTN PRIdFASTN PRIdMAX PRIdPTR
PRIiN PRIiLEASTN PRIiFASTN PRIiMAX PRIiPTR
3 The fprintf macros for unsigned integers are:
PRIoN PRIoLEASTN PRIoFASTN PRIoMAX PRIoPTR
PRIuN PRIuLEASTN PRIuFASTN PRIuMAX PRIuPTR
PRIxN PRIxLEASTN PRIxFASTN PRIxMAX PRIxPTR
PRIXN PRIXLEASTN PRIXFASTN PRIXMAX PRIXPTR

Like you see, standard don't give any specifier to print an intN_t in hexadecimal format. The correct way to print it would be to cast it.

#include <stdint.h>
#include <stdio.h>
#include <inttypes.h>

int main(void) {
  int32_t x = -15;
  printf("%"PRIX32"\n", (uint32_t)x);
}

Overflow of unsigned integer are defined by C standard so the cast is not undefined. AFAIK

[Phlosioneer]

I think this was addressed by #46285

[Enet4]

@Phlosioneer That is correct! :) Closing.