Types with implicit user conversion to number are incorrectly printed when FMT_COMPILE is in use.

[PiotrZSL]

Problematic code:

#include <fmt/core.h>
#include <fmt/compile.h>
#include <fmt/ostream.h>
#include <boost/serialization/strong_typedef.hpp>

BOOST_STRONG_TYPEDEF(std::uint32_t, SomeMagicStrongType)

struct TypeWithCast
{
   operator const std::uint32_t&() const {
    return t;
  }
  operator std::uint32_t&() {
    return t;
  }

  std::uint32_t t = 'A';
};

int main() {
  SomeMagicStrongType value{50u};
  std::string s = fmt::format(FMT_COMPILE("Value of strongtype is {} and custom type is {}."), value, TypeWithCast());
  fmt::print("{}", s);
}

Output when FMT_COMPILE is used:
Value of strongtype is 2 and custom type is A.

Output when FMT_COMPILE is not used:
Value of strongtype is 50 and custom type is 65.

This is a break of backward compatibility.

[alexezeder]

Actually, this problem is caused not by compile-time API but by underlying calls - https://godbolt.org/z/bjGheazrG.

This is a break of backward compatibility.

More importantly, this was done in 7.0 version of {fmt} 😄 - https://godbolt.org/z/GExb3rY5c.

In the current version, this write() overload is invoked:

fmt/include/fmt/format.h

Lines 2109 to 2114 in df40e94

	template <typename Char, typename OutputIt>
	FMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt {
	auto it = reserve(out, 1);
	*it++ = value;
	return base_iterator(out, it);
	}

But this is happening only because mapped_type_constant (arg_mapper-based check) is not type::custom_type for the type with such conversion operator. But it is type::custom_type for types with conversion operators other than const-reference one.

And that's all from me, at least for today, since I have no idea how to make mapped_type_constant return type::custom_type for this type.

[vitaut]

Fixed in 028f227, thanks for reporting.