Implement support for to_string and implement PlainDate::to_string

[nekevss]

This PR implements the underlying code to implement Display, to_string, and to_ixdtf_string methods for nearly all the main built-ins aside from Duration, PlainYearMonth, and PlainMonthDay.

The majority of the backing implementation will most likely need to eventually be moved into the ixdtf crate, but until that is complete and worked, this should allow us to move forward with the implementation and testing in Boa against test262.

[sffc]

Praise: Thanks for using writeable :)

[sffc]

Suggestion: your impl Writeable may benefit from a write_len function since it looks fairly cheap to pre-compute. You could add one later.

[sffc]

Nit: You should avoid returning core::fmt::Error because it gets turned into an unhandled panic! in most call sites. You should try and ensure that your nanoseconds are in range by adding invariants to the type being formatted, instead of returning an error in the Writeable impl.

If you need to return errors from the Writeable impl, consider using TryWriteable instead.

[sffc]

Observation: The compiler can often optimize out a small fixed operation; for example, I think it changes /10 from an expensive div instruction to some clever bit shifting stuff. However, since the divisor is changing on each iteration of the loop, the compiler is less likely to do this optimization and may leave around an actual div instruction in the assembly.

You should consider making a little helper that returns [u8; 9] with the ASCII bytes of a padded 9-digit number, which you can fill in backwards to get the /10 optimization, and then write the subslice that you need from it into the sink. You can use it in all of these places where you need to write a padded number to a string. Unfortunately this may involve a small amount of unsafe code since you need to assert that the temporary [u8; 9] buffer is UTF-8. However, hopefully once core::ascii gets stabilized, you will make such code safe.

I may even support adding the helper function to writeable itself, but you should first develop it here.

[raskad]

Looks good

[raskad]

Suggested change

// let mut precision_check = 0;

[sffc]

Nit: Use assert_writeable_eq instead of assert_eq in order to test the Writeable impl more thoroughly (such as the correctness of writeable_length_hint)

[sffc]

Suggestion: I like how you use impl Writeable for u8 here. I think you can do that with the u32 as well.

Something like:

let mut max = 1e9;
while max > nanoseconds {
    sink.write_char('0')?;
    max /= 10;
}
nanoseconds.write_to(sink)?;

And then you don't need any unsafe code.

[nekevss]

Does that fix output the nanoseconds according to what would be expected? If I'm reading that write, it would left pad nanoseconds to always be 9 digits, but the concern with this is to trim trailing zeros on nanosecond according to the desired precision.

nanoseconds = 123_000_000, should only print .123 or the desired precision, i.e. precision = 5 would be .12300, but this would print 123000000

The idea for the use of unsafe in the function was to try and optimize out the div instruction from the below, which I think would be the equivalent to the above.

   let mut divisor = 1_000_000_000;
    while divisor >= 1 && nanoseconds != 0 {
        (nanoseconds / divisor).write_to(sink)?;
        nanoseconds %= divisor;
        divisor /= 10;
    }

EDIT: Although another option may be to deconstruct and then reconstruct the u32? That may be an option to avoid unsafe

[nekevss]

Actually, nevermind. We can just write the digits manually as u8s