From 8a912b56087b5f08a62cfb862d3600908f14428e Mon Sep 17 00:00:00 2001
From: Mathspy <mathspy257@gmail.com>
Date: Mon, 6 Dec 2021 18:28:57 +0200
Subject: [PATCH 01/12] Add io::Write -> fmt::Write compatibility type

---
 src/formatting/formattable.rs | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/formatting/formattable.rs b/src/formatting/formattable.rs
index da2db0e14..042f46b25 100644
--- a/src/formatting/formattable.rs
+++ b/src/formatting/formattable.rs
@@ -1,7 +1,7 @@
 //! A trait that can be used to format an item from its components.
 
 use core::ops::Deref;
-use std::io;
+use std::{fmt, io};
 
 use crate::format_description::well_known::{Rfc2822, Rfc3339};
 use crate::format_description::FormatItem;
@@ -19,6 +19,27 @@ impl Formattable for Rfc3339 {}
 impl Formattable for Rfc2822 {}
 impl<T: Deref> Formattable for T where T::Target: Formattable {}
 
+struct Compat<'a, W: io::Write> {
+    writer: &'a mut W,
+    bytes_written: usize,
+    error: Option<io::Error>,
+}
+
+impl<'a, W> fmt::Write for Compat<'a, W>
+where
+    W: io::Write,
+{
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.writer
+            .write_all(s.as_bytes())
+            .map(|_| self.bytes_written += s.len())
+            .map_err(|error| {
+                self.error = Some(error);
+                fmt::Error
+            })
+    }
+}
+
 /// Seal the trait to prevent downstream users from implementing it.
 mod sealed {
     #[allow(clippy::wildcard_imports)]

From eeaf28a17ff4bd515dbc880cad22b25140ae921b Mon Sep 17 00:00:00 2001
From: Mathspy <mathspy257@gmail.com>
Date: Mon, 6 Dec 2021 18:31:44 +0200
Subject: [PATCH 02/12] Replace old format_into and give it a default impl

---
 src/error/format.rs           | 10 ++++++++++
 src/formatting/formattable.rs | 31 +++++++++++++++++++++++++++----
 2 files changed, 37 insertions(+), 4 deletions(-)

diff --git a/src/error/format.rs b/src/error/format.rs
index 723a4eb82..ff5cd09a6 100644
--- a/src/error/format.rs
+++ b/src/error/format.rs
@@ -21,6 +21,8 @@ pub enum Format {
     InvalidComponent(&'static str),
     /// A value of `std::io::Error` was returned internally.
     StdIo(io::Error),
+    /// A value of `std::fmt::Error` was returned internally.
+    StdFmt(fmt::Error),
 }
 
 impl fmt::Display for Format {
@@ -36,6 +38,7 @@ impl fmt::Display for Format {
                 component
             ),
             Self::StdIo(err) => err.fmt(f),
+            Self::StdFmt(err) => err.fmt(f),
         }
     }
 }
@@ -46,6 +49,12 @@ impl From<io::Error> for Format {
     }
 }
 
+impl From<fmt::Error> for Format {
+    fn from(err: fmt::Error) -> Self {
+        Self::StdFmt(err)
+    }
+}
+
 impl TryFrom<Format> for io::Error {
     type Error = error::DifferentVariant;
 
@@ -63,6 +72,7 @@ impl std::error::Error for Format {
         match *self {
             Self::InsufficientTypeInformation | Self::InvalidComponent(_) => None,
             Self::StdIo(ref err) => Some(err),
+            Self::StdFmt(ref err) => Some(err),
         }
     }
 }
diff --git a/src/formatting/formattable.rs b/src/formatting/formattable.rs
index 042f46b25..9e875c684 100644
--- a/src/formatting/formattable.rs
+++ b/src/formatting/formattable.rs
@@ -48,14 +48,37 @@ mod sealed {
     /// Format the item using a format description, the intended output, and the various components.
     #[cfg_attr(__time_03_docs, doc(cfg(feature = "formatting")))]
     pub trait Sealed {
-        /// Format the item into the provided output, returning the number of bytes written.
+        /// Format the item into the provided output.
         fn format_into(
+            &self,
+            output: &mut impl fmt::Write,
+            date: Option<Date>,
+            time: Option<Time>,
+            offset: Option<UtcOffset>,
+        ) -> Result<(), error::Format>;
+
+        /// Format the item into the provided output, returning the number of bytes written.
+        fn format_into_old(
             &self,
             output: &mut impl io::Write,
             date: Option<Date>,
             time: Option<Time>,
             offset: Option<UtcOffset>,
-        ) -> Result<usize, error::Format>;
+        ) -> Result<usize, error::Format> {
+            let mut compat = Compat {
+                writer: output,
+                bytes_written: 0,
+                error: None,
+            };
+            self.format_into(&mut compat, date, time, offset)
+                .map(|_| compat.bytes_written)
+                .map_err(|fmt_error| {
+                    compat
+                        .error
+                        .map(error::Format::from)
+                        .unwrap_or_else(|| error::Format::from(fmt_error))
+                })
+        }
 
         /// Format the item directly to a `String`.
         fn format(
@@ -64,9 +87,9 @@ mod sealed {
             time: Option<Time>,
             offset: Option<UtcOffset>,
         ) -> Result<String, error::Format> {
-            let mut buf = Vec::new();
+            let mut buf = String::new();
             self.format_into(&mut buf, date, time, offset)?;
-            Ok(String::from_utf8_lossy(&buf).into_owned())
+            Ok(buf)
         }
     }
 }

From 3216f2d98060ce82f62a75dc6b07cec92135a480 Mon Sep 17 00:00:00 2001
From: Mathspy <mathspy257@gmail.com>
Date: Mon, 6 Dec 2021 18:35:39 +0200
Subject: [PATCH 03/12] Switch formatting machinery to fmt::Write

---
 src/formatting/formattable.rs | 120 +++++++++++-------------
 src/formatting/mod.rs         | 167 +++++++++++++++++-----------------
 2 files changed, 137 insertions(+), 150 deletions(-)

diff --git a/src/formatting/formattable.rs b/src/formatting/formattable.rs
index 9e875c684..ddebe118d 100644
--- a/src/formatting/formattable.rs
+++ b/src/formatting/formattable.rs
@@ -98,18 +98,20 @@ mod sealed {
 impl<'a> sealed::Sealed for FormatItem<'a> {
     fn format_into(
         &self,
-        output: &mut impl io::Write,
+        output: &mut impl fmt::Write,
         date: Option<Date>,
         time: Option<Time>,
         offset: Option<UtcOffset>,
-    ) -> Result<usize, error::Format> {
+    ) -> Result<(), error::Format> {
         Ok(match *self {
-            Self::Literal(literal) => write(output, literal)?,
+            Self::Literal(literal) => {
+                output.write_str(String::from_utf8_lossy(literal).as_ref())?
+            }
             Self::Component(component) => format_component(output, component, date, time, offset)?,
             Self::Compound(items) => items.format_into(output, date, time, offset)?,
             Self::Optional(item) => item.format_into(output, date, time, offset)?,
             Self::First(items) => match items {
-                [] => 0,
+                [] => (),
                 [item, ..] => item.format_into(output, date, time, offset)?,
             },
         })
@@ -119,16 +121,15 @@ impl<'a> sealed::Sealed for FormatItem<'a> {
 impl<'a> sealed::Sealed for [FormatItem<'a>] {
     fn format_into(
         &self,
-        output: &mut impl io::Write,
+        output: &mut impl fmt::Write,
         date: Option<Date>,
         time: Option<Time>,
         offset: Option<UtcOffset>,
-    ) -> Result<usize, error::Format> {
-        let mut bytes = 0;
+    ) -> Result<(), error::Format> {
         for item in self.iter() {
-            bytes += item.format_into(output, date, time, offset)?;
+            item.format_into(output, date, time, offset)?;
         }
-        Ok(bytes)
+        Ok(())
     }
 }
 
@@ -138,11 +139,11 @@ where
 {
     fn format_into(
         &self,
-        output: &mut impl io::Write,
+        output: &mut impl fmt::Write,
         date: Option<Date>,
         time: Option<Time>,
         offset: Option<UtcOffset>,
-    ) -> Result<usize, error::Format> {
+    ) -> Result<(), error::Format> {
         self.deref().format_into(output, date, time, offset)
     }
 }
@@ -152,17 +153,15 @@ where
 impl sealed::Sealed for Rfc2822 {
     fn format_into(
         &self,
-        output: &mut impl io::Write,
+        output: &mut impl fmt::Write,
         date: Option<Date>,
         time: Option<Time>,
         offset: Option<UtcOffset>,
-    ) -> Result<usize, error::Format> {
+    ) -> Result<(), error::Format> {
         let date = date.ok_or(error::Format::InsufficientTypeInformation)?;
         let time = time.ok_or(error::Format::InsufficientTypeInformation)?;
         let offset = offset.ok_or(error::Format::InsufficientTypeInformation)?;
 
-        let mut bytes = 0;
-
         let (year, month, day) = date.to_calendar_date();
 
         if year < 1900 {
@@ -172,46 +171,43 @@ impl sealed::Sealed for Rfc2822 {
             return Err(error::Format::InvalidComponent("offset_second"));
         }
 
-        bytes += write(
+        write(
             output,
             &WEEKDAY_NAMES[date.weekday().number_days_from_monday() as usize][..3],
         )?;
-        bytes += write(output, b", ")?;
-        bytes += format_number_pad_zero::<_, _, 2>(output, day)?;
-        bytes += write(output, b" ")?;
-        bytes += write(output, &MONTH_NAMES[month as usize - 1][..3])?;
-        bytes += write(output, b" ")?;
-        bytes += format_number_pad_zero::<_, _, 4>(output, year as u32)?;
-        bytes += write(output, b" ")?;
-        bytes += format_number_pad_zero::<_, _, 2>(output, time.hour())?;
-        bytes += write(output, b":")?;
-        bytes += format_number_pad_zero::<_, _, 2>(output, time.minute())?;
-        bytes += write(output, b":")?;
-        bytes += format_number_pad_zero::<_, _, 2>(output, time.second())?;
-        bytes += write(output, b" ")?;
-        bytes += write(output, if offset.is_negative() { b"-" } else { b"+" })?;
-        bytes += format_number_pad_zero::<_, _, 2>(output, offset.whole_hours().unsigned_abs())?;
-        bytes +=
-            format_number_pad_zero::<_, _, 2>(output, offset.minutes_past_hour().unsigned_abs())?;
+        write(output, ", ")?;
+        format_number_pad_zero::<_, _, 2>(output, day)?;
+        write(output, " ")?;
+        write(output, &MONTH_NAMES[month as usize - 1][..3])?;
+        write(output, " ")?;
+        format_number_pad_zero::<_, _, 4>(output, year as u32)?;
+        write(output, " ")?;
+        format_number_pad_zero::<_, _, 2>(output, time.hour())?;
+        write(output, ":")?;
+        format_number_pad_zero::<_, _, 2>(output, time.minute())?;
+        write(output, ":")?;
+        format_number_pad_zero::<_, _, 2>(output, time.second())?;
+        write(output, " ")?;
+        write(output, if offset.is_negative() { "-" } else { "+" })?;
+        format_number_pad_zero::<_, _, 2>(output, offset.whole_hours().unsigned_abs())?;
+        format_number_pad_zero::<_, _, 2>(output, offset.minutes_past_hour().unsigned_abs())?;
 
-        Ok(bytes)
+        Ok(())
     }
 }
 
 impl sealed::Sealed for Rfc3339 {
     fn format_into(
         &self,
-        output: &mut impl io::Write,
+        output: &mut impl fmt::Write,
         date: Option<Date>,
         time: Option<Time>,
         offset: Option<UtcOffset>,
-    ) -> Result<usize, error::Format> {
+    ) -> Result<(), error::Format> {
         let date = date.ok_or(error::Format::InsufficientTypeInformation)?;
         let time = time.ok_or(error::Format::InsufficientTypeInformation)?;
         let offset = offset.ok_or(error::Format::InsufficientTypeInformation)?;
 
-        let mut bytes = 0;
-
         let year = date.year();
 
         if !(0..10_000).contains(&year) {
@@ -221,23 +217,23 @@ impl sealed::Sealed for Rfc3339 {
             return Err(error::Format::InvalidComponent("offset_second"));
         }
 
-        bytes += format_number_pad_zero::<_, _, 4>(output, year as u32)?;
-        bytes += write(output, &[b'-'])?;
-        bytes += format_number_pad_zero::<_, _, 2>(output, date.month() as u8)?;
-        bytes += write(output, &[b'-'])?;
-        bytes += format_number_pad_zero::<_, _, 2>(output, date.day())?;
-        bytes += write(output, &[b'T'])?;
-        bytes += format_number_pad_zero::<_, _, 2>(output, time.hour())?;
-        bytes += write(output, &[b':'])?;
-        bytes += format_number_pad_zero::<_, _, 2>(output, time.minute())?;
-        bytes += write(output, &[b':'])?;
-        bytes += format_number_pad_zero::<_, _, 2>(output, time.second())?;
+        format_number_pad_zero::<_, _, 4>(output, year as u32)?;
+        write(output, "-")?;
+        format_number_pad_zero::<_, _, 2>(output, date.month() as u8)?;
+        write(output, "-")?;
+        format_number_pad_zero::<_, _, 2>(output, date.day())?;
+        write(output, "T")?;
+        format_number_pad_zero::<_, _, 2>(output, time.hour())?;
+        write(output, ":")?;
+        format_number_pad_zero::<_, _, 2>(output, time.minute())?;
+        write(output, ":")?;
+        format_number_pad_zero::<_, _, 2>(output, time.second())?;
 
         #[allow(clippy::if_not_else)]
         if time.nanosecond() != 0 {
             let nanos = time.nanosecond();
-            bytes += write(output, &[b'.'])?;
-            bytes += if nanos % 10 != 0 {
+            write(output, ".")?;
+            if nanos % 10 != 0 {
                 format_number_pad_zero::<_, _, 9>(output, nanos)
             } else if (nanos / 10) % 10 != 0 {
                 format_number_pad_zero::<_, _, 8>(output, nanos / 10)
@@ -259,24 +255,16 @@ impl sealed::Sealed for Rfc3339 {
         }
 
         if offset == UtcOffset::UTC {
-            bytes += write(output, &[b'Z'])?;
-            return Ok(bytes);
+            write(output, "Z")?;
+            return Ok(());
         }
 
-        bytes += write(
-            output,
-            if offset.is_negative() {
-                &[b'-']
-            } else {
-                &[b'+']
-            },
-        )?;
-        bytes += format_number_pad_zero::<_, _, 2>(output, offset.whole_hours().unsigned_abs())?;
-        bytes += write(output, &[b':'])?;
-        bytes +=
-            format_number_pad_zero::<_, _, 2>(output, offset.minutes_past_hour().unsigned_abs())?;
+        write(output, if offset.is_negative() { "-" } else { "+" })?;
+        format_number_pad_zero::<_, _, 2>(output, offset.whole_hours().unsigned_abs())?;
+        write(output, ":")?;
+        format_number_pad_zero::<_, _, 2>(output, offset.minutes_past_hour().unsigned_abs())?;
 
-        Ok(bytes)
+        Ok(())
     }
 }
 // endregion well-known formats
diff --git a/src/formatting/mod.rs b/src/formatting/mod.rs
index 791a3cff4..3df6e97f2 100644
--- a/src/formatting/mod.rs
+++ b/src/formatting/mod.rs
@@ -2,37 +2,37 @@
 
 pub(crate) mod formattable;
 
-use std::io;
+use std::fmt;
 
 pub use self::formattable::Formattable;
 use crate::format_description::{modifier, Component};
 use crate::{error, Date, Time, UtcOffset};
 
 #[allow(clippy::missing_docs_in_private_items)]
-const MONTH_NAMES: [&[u8]; 12] = [
-    b"January",
-    b"February",
-    b"March",
-    b"April",
-    b"May",
-    b"June",
-    b"July",
-    b"August",
-    b"September",
-    b"October",
-    b"November",
-    b"December",
+const MONTH_NAMES: [&str; 12] = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December",
 ];
 
 #[allow(clippy::missing_docs_in_private_items)]
-const WEEKDAY_NAMES: [&[u8]; 7] = [
-    b"Monday",
-    b"Tuesday",
-    b"Wednesday",
-    b"Thursday",
-    b"Friday",
-    b"Saturday",
-    b"Sunday",
+const WEEKDAY_NAMES: [&str; 7] = [
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday",
+    "Sunday",
 ];
 
 // region: extension trait
@@ -116,23 +116,26 @@ impl DigitCount for u32 {
 // endregion extension trait
 
 /// Write all bytes to the output, returning the number of bytes written.
-fn write(output: &mut impl io::Write, bytes: &[u8]) -> io::Result<usize> {
-    output.write_all(bytes)?;
-    Ok(bytes.len())
+fn write(output: &mut impl fmt::Write, bytes: &str) -> fmt::Result {
+    output.write_str(bytes)
 }
 
 /// Format a number with the provided padding and width.
 ///
 /// The sign must be written by the caller.
-pub(crate) fn format_number<W: io::Write, V: itoa::Integer + DigitCount + Copy, const WIDTH: u8>(
+pub(crate) fn format_number<
+    W: fmt::Write,
+    V: itoa::Integer + DigitCount + Copy,
+    const WIDTH: u8,
+>(
     output: &mut W,
     value: V,
     padding: modifier::Padding,
-) -> Result<usize, io::Error> {
+) -> Result<(), fmt::Error> {
     match padding {
         modifier::Padding::Space => format_number_pad_space::<_, _, WIDTH>(output, value),
         modifier::Padding::Zero => format_number_pad_zero::<_, _, WIDTH>(output, value),
-        modifier::Padding::None => write(output, itoa::Buffer::new().format(value).as_bytes()),
+        modifier::Padding::None => write(output, itoa::Buffer::new().format(value)),
     }
 }
 
@@ -140,50 +143,48 @@ pub(crate) fn format_number<W: io::Write, V: itoa::Integer + DigitCount + Copy,
 ///
 /// The sign must be written by the caller.
 pub(crate) fn format_number_pad_space<
-    W: io::Write,
+    W: fmt::Write,
     V: itoa::Integer + DigitCount + Copy,
     const WIDTH: u8,
 >(
     output: &mut W,
     value: V,
-) -> Result<usize, io::Error> {
-    let mut bytes = 0;
+) -> Result<(), fmt::Error> {
     for _ in 0..(WIDTH.saturating_sub(value.num_digits())) {
-        bytes += write(output, &[b' '])?;
+        write(output, " ")?;
     }
-    bytes += write(output, itoa::Buffer::new().format(value).as_bytes())?;
-    Ok(bytes)
+    write(output, itoa::Buffer::new().format(value))?;
+    Ok(())
 }
 
 /// Format a number with the provided width and zeros as padding.
 ///
 /// The sign must be written by the caller.
 pub(crate) fn format_number_pad_zero<
-    W: io::Write,
+    W: fmt::Write,
     V: itoa::Integer + DigitCount + Copy,
     const WIDTH: u8,
 >(
     output: &mut W,
     value: V,
-) -> Result<usize, io::Error> {
-    let mut bytes = 0;
+) -> Result<(), fmt::Error> {
     for _ in 0..(WIDTH.saturating_sub(value.num_digits())) {
-        bytes += write(output, &[b'0'])?;
+        write(output, "0")?;
     }
-    bytes += write(output, itoa::Buffer::new().format(value).as_bytes())?;
-    Ok(bytes)
+    write(output, itoa::Buffer::new().format(value))?;
+    Ok(())
 }
 
 /// Format the provided component into the designated output. An `Err` will be returned if the
 /// component requires information that it does not provide or if the value cannot be output to the
 /// stream.
 pub(crate) fn format_component(
-    output: &mut impl io::Write,
+    output: &mut impl fmt::Write,
     component: Component,
     date: Option<Date>,
     time: Option<Time>,
     offset: Option<UtcOffset>,
-) -> Result<usize, error::Format> {
+) -> Result<(), error::Format> {
     use Component::*;
     Ok(match (component, date, time, offset) {
         (Day(modifier), Some(date), ..) => fmt_day(output, date, modifier)?,
@@ -207,23 +208,23 @@ pub(crate) fn format_component(
 // region: date formatters
 /// Format the day into the designated output.
 fn fmt_day(
-    output: &mut impl io::Write,
+    output: &mut impl fmt::Write,
     date: Date,
     modifier::Day { padding }: modifier::Day,
-) -> Result<usize, io::Error> {
+) -> Result<(), fmt::Error> {
     format_number::<_, _, 2>(output, date.day(), padding)
 }
 
 /// Format the month into the designated output.
 fn fmt_month(
-    output: &mut impl io::Write,
+    output: &mut impl fmt::Write,
     date: Date,
     modifier::Month {
         padding,
         repr,
         case_sensitive: _, // no effect on formatting
     }: modifier::Month,
-) -> Result<usize, io::Error> {
+) -> Result<(), fmt::Error> {
     match repr {
         modifier::MonthRepr::Numerical => {
             format_number::<_, _, 2>(output, date.month() as u8, padding)
@@ -235,23 +236,23 @@ fn fmt_month(
 
 /// Format the ordinal into the designated output.
 fn fmt_ordinal(
-    output: &mut impl io::Write,
+    output: &mut impl fmt::Write,
     date: Date,
     modifier::Ordinal { padding }: modifier::Ordinal,
-) -> Result<usize, io::Error> {
+) -> Result<(), fmt::Error> {
     format_number::<_, _, 3>(output, date.ordinal(), padding)
 }
 
 /// Format the weekday into the designated output.
 fn fmt_weekday(
-    output: &mut impl io::Write,
+    output: &mut impl fmt::Write,
     date: Date,
     modifier::Weekday {
         repr,
         one_indexed,
         case_sensitive: _, // no effect on formatting
     }: modifier::Weekday,
-) -> Result<usize, io::Error> {
+) -> Result<(), fmt::Error> {
     match repr {
         modifier::WeekdayRepr::Short => write(
             output,
@@ -276,10 +277,10 @@ fn fmt_weekday(
 
 /// Format the week number into the designated output.
 fn fmt_week_number(
-    output: &mut impl io::Write,
+    output: &mut impl fmt::Write,
     date: Date,
     modifier::WeekNumber { padding, repr }: modifier::WeekNumber,
-) -> Result<usize, io::Error> {
+) -> Result<(), fmt::Error> {
     format_number::<_, _, 2>(
         output,
         match repr {
@@ -293,7 +294,7 @@ fn fmt_week_number(
 
 /// Format the year into the designated output.
 fn fmt_year(
-    output: &mut impl io::Write,
+    output: &mut impl fmt::Write,
     date: Date,
     modifier::Year {
         padding,
@@ -301,7 +302,7 @@ fn fmt_year(
         iso_week_based,
         sign_is_mandatory,
     }: modifier::Year,
-) -> Result<usize, io::Error> {
+) -> Result<(), fmt::Error> {
     let full_year = if iso_week_based {
         date.iso_year_week().0
     } else {
@@ -319,29 +320,28 @@ fn fmt_year(
         modifier::YearRepr::Full => format_number::<_, _, 4>,
         modifier::YearRepr::LastTwo => format_number::<_, _, 2>,
     };
-    let mut bytes = 0;
     if repr != modifier::YearRepr::LastTwo {
         if full_year < 0 {
-            bytes += write(output, &[b'-'])?;
+            write(output, "-")?;
         } else if sign_is_mandatory || cfg!(feature = "large-dates") && full_year >= 10_000 {
-            bytes += write(output, &[b'+'])?;
+            write(output, "+")?;
         }
     }
-    bytes += format_number(output, value.unsigned_abs(), padding)?;
-    Ok(bytes)
+    format_number(output, value.unsigned_abs(), padding)?;
+    Ok(())
 }
 // endregion date formatters
 
 // region: time formatters
 /// Format the hour into the designated output.
 fn fmt_hour(
-    output: &mut impl io::Write,
+    output: &mut impl fmt::Write,
     time: Time,
     modifier::Hour {
         padding,
         is_12_hour_clock,
     }: modifier::Hour,
-) -> Result<usize, io::Error> {
+) -> Result<(), fmt::Error> {
     let value = match (time.hour(), is_12_hour_clock) {
         (hour, false) => hour,
         (0 | 12, true) => 12,
@@ -353,45 +353,45 @@ fn fmt_hour(
 
 /// Format the minute into the designated output.
 fn fmt_minute(
-    output: &mut impl io::Write,
+    output: &mut impl fmt::Write,
     time: Time,
     modifier::Minute { padding }: modifier::Minute,
-) -> Result<usize, io::Error> {
+) -> Result<(), fmt::Error> {
     format_number::<_, _, 2>(output, time.minute(), padding)
 }
 
 /// Format the period into the designated output.
 fn fmt_period(
-    output: &mut impl io::Write,
+    output: &mut impl fmt::Write,
     time: Time,
     modifier::Period {
         is_uppercase,
         case_sensitive: _, // no effect on formatting
     }: modifier::Period,
-) -> Result<usize, io::Error> {
+) -> Result<(), fmt::Error> {
     match (time.hour() >= 12, is_uppercase) {
-        (false, false) => write(output, b"am"),
-        (false, true) => write(output, b"AM"),
-        (true, false) => write(output, b"pm"),
-        (true, true) => write(output, b"PM"),
+        (false, false) => write(output, "am"),
+        (false, true) => write(output, "AM"),
+        (true, false) => write(output, "pm"),
+        (true, true) => write(output, "PM"),
     }
 }
 
 /// Format the second into the designated output.
 fn fmt_second(
-    output: &mut impl io::Write,
+    output: &mut impl fmt::Write,
     time: Time,
     modifier::Second { padding }: modifier::Second,
-) -> Result<usize, io::Error> {
+) -> Result<(), fmt::Error> {
     format_number::<_, _, 2>(output, time.second(), padding)
 }
 
 /// Format the subsecond into the designated output.
-fn fmt_subsecond<W: io::Write>(
+fn fmt_subsecond<W: fmt::Write>(
     output: &mut W,
     time: Time,
     modifier::Subsecond { digits }: modifier::Subsecond,
-) -> Result<usize, io::Error> {
+) -> Result<(), fmt::Error> {
     use modifier::SubsecondDigits::*;
     let nanos = time.nanosecond();
 
@@ -420,38 +420,37 @@ fn fmt_subsecond<W: io::Write>(
 // region: offset formatters
 /// Format the offset hour into the designated output.
 fn fmt_offset_hour(
-    output: &mut impl io::Write,
+    output: &mut impl fmt::Write,
     offset: UtcOffset,
     modifier::OffsetHour {
         padding,
         sign_is_mandatory,
     }: modifier::OffsetHour,
-) -> Result<usize, io::Error> {
-    let mut bytes = 0;
+) -> Result<(), fmt::Error> {
     if offset.is_negative() {
-        bytes += write(output, &[b'-'])?;
+        write(output, "-")?;
     } else if sign_is_mandatory {
-        bytes += write(output, &[b'+'])?;
+        write(output, "+")?;
     }
-    bytes += format_number::<_, _, 2>(output, offset.whole_hours().unsigned_abs(), padding)?;
-    Ok(bytes)
+    format_number::<_, _, 2>(output, offset.whole_hours().unsigned_abs(), padding)?;
+    Ok(())
 }
 
 /// Format the offset minute into the designated output.
 fn fmt_offset_minute(
-    output: &mut impl io::Write,
+    output: &mut impl fmt::Write,
     offset: UtcOffset,
     modifier::OffsetMinute { padding }: modifier::OffsetMinute,
-) -> Result<usize, io::Error> {
+) -> Result<(), fmt::Error> {
     format_number::<_, _, 2>(output, offset.minutes_past_hour().unsigned_abs(), padding)
 }
 
 /// Format the offset second into the designated output.
 fn fmt_offset_second(
-    output: &mut impl io::Write,
+    output: &mut impl fmt::Write,
     offset: UtcOffset,
     modifier::OffsetSecond { padding }: modifier::OffsetSecond,
-) -> Result<usize, io::Error> {
+) -> Result<(), fmt::Error> {
     format_number::<_, _, 2>(output, offset.seconds_past_minute().unsigned_abs(), padding)
 }
 // endregion offset formatters

From 1906ce75d7716cdba23e10e4ffac1c0b7e77f3de Mon Sep 17 00:00:00 2001
From: Mathspy <mathspy257@gmail.com>
Date: Mon, 6 Dec 2021 18:38:44 +0200
Subject: [PATCH 04/12] Update structs to call old format_into

---
 src/date.rs                | 2 +-
 src/offset_date_time.rs    | 2 +-
 src/primitive_date_time.rs | 2 +-
 src/time.rs                | 2 +-
 src/utc_offset.rs          | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/date.rs b/src/date.rs
index c0a3bec8f..68e5f3f7e 100644
--- a/src/date.rs
+++ b/src/date.rs
@@ -824,7 +824,7 @@ impl Date {
         output: &mut impl io::Write,
         format: &(impl Formattable + ?Sized),
     ) -> Result<usize, error::Format> {
-        format.format_into(output, Some(self), None, None)
+        format.format_into_old(output, Some(self), None, None)
     }
 
     /// Format the `Date` using the provided [format description](crate::format_description).
diff --git a/src/offset_date_time.rs b/src/offset_date_time.rs
index ec2d6c678..62598ceba 100644
--- a/src/offset_date_time.rs
+++ b/src/offset_date_time.rs
@@ -897,7 +897,7 @@ impl OffsetDateTime {
         format: &(impl Formattable + ?Sized),
     ) -> Result<usize, error::Format> {
         let local = self.utc_datetime.utc_to_offset(self.offset);
-        format.format_into(
+        format.format_into_old(
             output,
             Some(local.date),
             Some(local.time),
diff --git a/src/primitive_date_time.rs b/src/primitive_date_time.rs
index a2c5a2505..ba3f0aad2 100644
--- a/src/primitive_date_time.rs
+++ b/src/primitive_date_time.rs
@@ -662,7 +662,7 @@ impl PrimitiveDateTime {
         output: &mut impl io::Write,
         format: &(impl Formattable + ?Sized),
     ) -> Result<usize, error::Format> {
-        format.format_into(output, Some(self.date), Some(self.time), None)
+        format.format_into_old(output, Some(self.date), Some(self.time), None)
     }
 
     /// Format the `PrimitiveDateTime` using the provided [format
diff --git a/src/time.rs b/src/time.rs
index 6bf2def14..0427cd482 100644
--- a/src/time.rs
+++ b/src/time.rs
@@ -459,7 +459,7 @@ impl Time {
         output: &mut impl io::Write,
         format: &(impl Formattable + ?Sized),
     ) -> Result<usize, crate::error::Format> {
-        format.format_into(output, None, Some(self), None)
+        format.format_into_old(output, None, Some(self), None)
     }
 
     /// Format the `Time` using the provided [format description](crate::format_description).
diff --git a/src/utc_offset.rs b/src/utc_offset.rs
index 65ae5fa41..fae216b4a 100644
--- a/src/utc_offset.rs
+++ b/src/utc_offset.rs
@@ -263,7 +263,7 @@ impl UtcOffset {
         output: &mut impl io::Write,
         format: &(impl Formattable + ?Sized),
     ) -> Result<usize, error::Format> {
-        format.format_into(output, None, None, Some(self))
+        format.format_into_old(output, None, None, Some(self))
     }
 
     /// Format the `UtcOffset` using the provided [format description](crate::format_description).

From 31637ffeedd3b8a4161b91ddeb7b8db91f231247 Mon Sep 17 00:00:00 2001
From: Mathspy <mathspy257@gmail.com>
Date: Mon, 6 Dec 2021 18:41:51 +0200
Subject: [PATCH 05/12] Add format_into_fmt_writer methods

---
 src/date.rs                | 19 +++++++++++++++++++
 src/offset_date_time.rs    | 30 ++++++++++++++++++++++++++++++
 src/primitive_date_time.rs | 21 +++++++++++++++++++++
 src/time.rs                | 19 +++++++++++++++++++
 src/utc_offset.rs          | 20 ++++++++++++++++++++
 5 files changed, 109 insertions(+)

diff --git a/src/date.rs b/src/date.rs
index 68e5f3f7e..e93aa41ec 100644
--- a/src/date.rs
+++ b/src/date.rs
@@ -827,6 +827,25 @@ impl Date {
         format.format_into_old(output, Some(self), None, None)
     }
 
+    /// Format the `Date` using the provided [format description](crate::format_description).
+    ///
+    /// Exactly like [`Date::format_into`] but accepts a [`fmt::Write`] instead of an [`io::Write`]
+    /// ```rust
+    /// # use time::{format_description, macros::date};
+    /// let format = format_description::parse("[year]-[month]-[day]")?;
+    /// let mut buf = String::new();
+    /// date!(2020 - 01 - 02).format_into_fmt_writer(&mut buf, &format)?;
+    /// assert_eq!(buf, "2020-01-02");
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn format_into_fmt_writer(
+        self,
+        output: &mut impl fmt::Write,
+        format: &(impl Formattable + ?Sized),
+    ) -> Result<(), error::Format> {
+        format.format_into(output, Some(self), None, None)
+    }
+
     /// Format the `Date` using the provided [format description](crate::format_description).
     ///
     /// ```rust
diff --git a/src/offset_date_time.rs b/src/offset_date_time.rs
index 62598ceba..cb501b8b3 100644
--- a/src/offset_date_time.rs
+++ b/src/offset_date_time.rs
@@ -905,6 +905,36 @@ impl OffsetDateTime {
         )
     }
 
+    /// Format the `OffsetDateTime` using the provided [format
+    /// description](crate::format_description).
+    ///
+    /// Exactly like [`OffsetDateTime::format_into`] but accepts a [`fmt::Write`] instead of an
+    /// [`io::Write`]
+    /// ```rust
+    /// # use time::{format_description, macros::datetime};
+    /// let format = format_description::parse(
+    ///     "[year]-[month]-[day] [hour]:[minute]:[second] [offset_hour \
+    ///          sign:mandatory]:[offset_minute]:[offset_second]",
+    /// )?;
+    /// let mut buf = String::new();
+    /// datetime!(2020-01-02 03:04:05 +06:07:08).format_into_fmt_writer(&mut buf, &format)?;
+    /// assert_eq!(buf, "2020-01-02 03:04:05 +06:07:08");
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn format_into_fmt_writer(
+        self,
+        output: &mut impl fmt::Write,
+        format: &(impl Formattable + ?Sized),
+    ) -> Result<(), error::Format> {
+        let local = self.utc_datetime.utc_to_offset(self.offset);
+        format.format_into(
+            output,
+            Some(local.date),
+            Some(local.time),
+            Some(self.offset),
+        )
+    }
+
     /// Format the `OffsetDateTime` using the provided [format
     /// description](crate::format_description).
     ///
diff --git a/src/primitive_date_time.rs b/src/primitive_date_time.rs
index ba3f0aad2..d01e5a62a 100644
--- a/src/primitive_date_time.rs
+++ b/src/primitive_date_time.rs
@@ -665,6 +665,27 @@ impl PrimitiveDateTime {
         format.format_into_old(output, Some(self.date), Some(self.time), None)
     }
 
+    /// Format the `PrimitiveDateTime` using the provided [format
+    /// description](crate::format_description).
+    ///
+    /// Exactly like [`PrimitiveDateTime::format_into`] but accepts a [`fmt::Write`] instead of an
+    /// [`io::Write`]
+    /// ```rust
+    /// # use time::{format_description, macros::datetime};
+    /// let format = format_description::parse("[year]-[month]-[day] [hour]:[minute]:[second]")?;
+    /// let mut buf = String::new();
+    /// datetime!(2020-01-02 03:04:05).format_into_fmt_writer(&mut buf, &format)?;
+    /// assert_eq!(buf, "2020-01-02 03:04:05");
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn format_into_fmt_writer(
+        self,
+        output: &mut impl fmt::Write,
+        format: &(impl Formattable + ?Sized),
+    ) -> Result<(), error::Format> {
+        format.format_into(output, Some(self.date), Some(self.time), None)
+    }
+
     /// Format the `PrimitiveDateTime` using the provided [format
     /// description](crate::format_description).
     ///
diff --git a/src/time.rs b/src/time.rs
index 0427cd482..75ec3b263 100644
--- a/src/time.rs
+++ b/src/time.rs
@@ -462,6 +462,25 @@ impl Time {
         format.format_into_old(output, None, Some(self), None)
     }
 
+    /// Format the `Time` using the provided [format description](crate::format_description).
+    ///
+    /// Exactly like [`Time::format_into`] but accepts a [`fmt::Write`] instead of an [`io::Write`]
+    /// ```rust
+    /// # use time::{format_description, macros::time};
+    /// let format = format_description::parse("[hour]:[minute]:[second]")?;
+    /// let mut buf = String::new();
+    /// time!(12:00).format_into_fmt_writer(&mut buf, &format)?;
+    /// assert_eq!(buf, "12:00:00");
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn format_into_fmt_writer(
+        self,
+        output: &mut impl fmt::Write,
+        format: &(impl Formattable + ?Sized),
+    ) -> Result<(), crate::error::Format> {
+        format.format_into(output, None, Some(self), None)
+    }
+
     /// Format the `Time` using the provided [format description](crate::format_description).
     ///
     /// ```rust
diff --git a/src/utc_offset.rs b/src/utc_offset.rs
index fae216b4a..f9b7b658c 100644
--- a/src/utc_offset.rs
+++ b/src/utc_offset.rs
@@ -266,6 +266,26 @@ impl UtcOffset {
         format.format_into_old(output, None, None, Some(self))
     }
 
+    /// Format the `UtcOffset` using the provided [format description](crate::format_description).
+    ///
+    /// Exactly like [`UtcOffset::format_into`] but accepts a [`fmt::Write`] instead of an
+    /// [`io::Write`]
+    /// ```rust
+    /// # use time::{format_description, macros::offset};
+    /// let format = format_description::parse("[offset_hour sign:mandatory]:[offset_minute]")?;
+    /// let mut buf = String::new();
+    /// offset!(+1).format_into_fmt_writer(&mut buf, &format)?;
+    /// assert_eq!(buf, "+01:00");
+    /// # Ok::<_, time::Error>(())
+    /// ```
+    pub fn format_into_fmt_writer(
+        self,
+        output: &mut impl fmt::Write,
+        format: &(impl Formattable + ?Sized),
+    ) -> Result<(), error::Format> {
+        format.format_into(output, None, None, Some(self))
+    }
+
     /// Format the `UtcOffset` using the provided [format description](crate::format_description).
     ///
     /// ```rust

From 59a6deb7e5ee8378a950233fb62c79a49c03c37d Mon Sep 17 00:00:00 2001
From: Mathspy <mathspy257@gmail.com>
Date: Mon, 6 Dec 2021 19:32:48 +0200
Subject: [PATCH 06/12] Added format_into_fmt_writer to integeration tests

---
 tests/integration/formatting.rs | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/tests/integration/formatting.rs b/tests/integration/formatting.rs
index 2537a9f3f..cede1736b 100644
--- a/tests/integration/formatting.rs
+++ b/tests/integration/formatting.rs
@@ -140,6 +140,12 @@ fn format_time() -> time::Result<()> {
                 .format_into(&mut io::sink(), format_description)
                 .is_ok()
         );
+        let mut buf = String::new();
+        assert!(
+            time!(13:02:03.456_789_012)
+                .format_into_fmt_writer(&mut buf, format_description)
+                .is_ok()
+        );
     }
 
     assert_eq!(
@@ -238,6 +244,12 @@ fn format_date() -> time::Result<()> {
                 .format_into(&mut io::sink(), format_description)
                 .is_ok()
         );
+        let mut buf = String::new();
+        assert!(
+            date!(2019 - 12 - 31)
+                .format_into_fmt_writer(&mut buf, format_description)
+                .is_ok()
+        );
     }
 
     Ok(())
@@ -290,6 +302,12 @@ fn format_offset() -> time::Result<()> {
                 .format_into(&mut io::sink(), format_description)
                 .is_ok()
         );
+        let mut buf = String::new();
+        assert!(
+            value
+                .format_into_fmt_writer(&mut buf, format_description)
+                .is_ok()
+        );
     }
 
     Ok(())
@@ -321,6 +339,12 @@ fn format_pdt() -> time::Result<()> {
             .format_into(&mut io::sink(), format_description)
             .is_ok()
     );
+    let mut buf = String::new();
+    assert!(
+        datetime!(1970-01-01 0:00)
+            .format_into_fmt_writer(&mut buf, format_description)
+            .is_ok()
+    );
 
     Ok(())
 }
@@ -353,6 +377,12 @@ fn format_odt() -> time::Result<()> {
             .format_into(&mut io::sink(), &format_description)
             .is_ok()
     );
+    let mut buf = String::new();
+    assert!(
+        datetime!(1970-01-01 0:00 UTC)
+            .format_into_fmt_writer(&mut buf, &format_description)
+            .is_ok()
+    );
 
     Ok(())
 }

From dde97b51ad16b0de148dda487ea24e74b1255dc4 Mon Sep 17 00:00:00 2001
From: Mathspy <mathspy257@gmail.com>
Date: Mon, 6 Dec 2021 20:27:52 +0200
Subject: [PATCH 07/12] I love you clippy

---
 src/formatting/formattable.rs | 12 +++++++++---
 src/formatting/mod.rs         |  6 ++++--
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/formatting/formattable.rs b/src/formatting/formattable.rs
index ddebe118d..e973c58de 100644
--- a/src/formatting/formattable.rs
+++ b/src/formatting/formattable.rs
@@ -19,9 +19,13 @@ impl Formattable for Rfc3339 {}
 impl Formattable for Rfc2822 {}
 impl<T: Deref> Formattable for T where T::Target: Formattable {}
 
+/// A compatibility layer to translate [`io::Write`] into [`fmt::Write`]
 struct Compat<'a, W: io::Write> {
+    /// The [`io::Write`]r to apply the translation on
     writer: &'a mut W,
+    /// The total bytes written into the writer so far
     bytes_written: usize,
+    /// The last error from the writer if it returned errors
     error: Option<io::Error>,
 }
 
@@ -76,7 +80,7 @@ mod sealed {
                     compat
                         .error
                         .map(error::Format::from)
-                        .unwrap_or_else(|| error::Format::from(fmt_error))
+                        .unwrap_or_else(|| fmt_error)
                 })
         }
 
@@ -103,7 +107,7 @@ impl<'a> sealed::Sealed for FormatItem<'a> {
         time: Option<Time>,
         offset: Option<UtcOffset>,
     ) -> Result<(), error::Format> {
-        Ok(match *self {
+        match *self {
             Self::Literal(literal) => {
                 output.write_str(String::from_utf8_lossy(literal).as_ref())?
             }
@@ -114,7 +118,9 @@ impl<'a> sealed::Sealed for FormatItem<'a> {
                 [] => (),
                 [item, ..] => item.format_into(output, date, time, offset)?,
             },
-        })
+        };
+
+        Ok(())
     }
 }
 
diff --git a/src/formatting/mod.rs b/src/formatting/mod.rs
index 3df6e97f2..59ed3126c 100644
--- a/src/formatting/mod.rs
+++ b/src/formatting/mod.rs
@@ -186,7 +186,7 @@ pub(crate) fn format_component(
     offset: Option<UtcOffset>,
 ) -> Result<(), error::Format> {
     use Component::*;
-    Ok(match (component, date, time, offset) {
+    match (component, date, time, offset) {
         (Day(modifier), Some(date), ..) => fmt_day(output, date, modifier)?,
         (Month(modifier), Some(date), ..) => fmt_month(output, date, modifier)?,
         (Ordinal(modifier), Some(date), ..) => fmt_ordinal(output, date, modifier)?,
@@ -202,7 +202,9 @@ pub(crate) fn format_component(
         (OffsetMinute(modifier), .., Some(offset)) => fmt_offset_minute(output, offset, modifier)?,
         (OffsetSecond(modifier), .., Some(offset)) => fmt_offset_second(output, offset, modifier)?,
         _ => return Err(error::Format::InsufficientTypeInformation),
-    })
+    };
+
+    Ok(())
 }
 
 // region: date formatters

From 09d9117eb9882dfdd75bb8f293b535220258e1a4 Mon Sep 17 00:00:00 2001
From: Mathspy <mathspy257@gmail.com>
Date: Mon, 6 Dec 2021 20:42:07 +0200
Subject: [PATCH 08/12] Add failing tests for format_into_fmt_writer

---
 tests/integration/formatting.rs | 80 +++++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)

diff --git a/tests/integration/formatting.rs b/tests/integration/formatting.rs
index cede1736b..777b51b83 100644
--- a/tests/integration/formatting.rs
+++ b/tests/integration/formatting.rs
@@ -1,3 +1,4 @@
+use std::fmt;
 use std::io::{self, ErrorKind};
 
 use time::format_description::well_known::{Rfc2822, Rfc3339};
@@ -509,6 +510,85 @@ fn failed_write() -> time::Result<()> {
     Ok(())
 }
 
+#[test]
+fn failed_fmt_write() -> time::Result<()> {
+    struct TestWriter;
+    impl fmt::Write for TestWriter {
+        fn write_str(&mut self, _s: &str) -> fmt::Result {
+            Err(fmt::Error)
+        }
+    }
+
+    let assert_err = |res| {
+        assert!(matches!(res, Err(time::error::Format::StdFmt(fmt::Error))));
+    };
+    assert_err(Time::MIDNIGHT.format_into_fmt_writer(&mut TestWriter, fd!("foo")));
+    assert_err(Time::MIDNIGHT.format_into_fmt_writer(&mut TestWriter, fd!("foo")));
+    assert_err(
+        Time::MIDNIGHT.format_into_fmt_writer(&mut TestWriter, &FormatItem::Compound(fd!("foo"))),
+    );
+    assert_err(Time::MIDNIGHT.format_into_fmt_writer(
+        &mut TestWriter,
+        &FormatItem::Optional(&FormatItem::Compound(fd!("foo"))),
+    ));
+    assert_err(OffsetDateTime::UNIX_EPOCH.format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(OffsetDateTime::UNIX_EPOCH.format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(OffsetDateTime::UNIX_EPOCH.format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(OffsetDateTime::UNIX_EPOCH.format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(OffsetDateTime::UNIX_EPOCH.format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(OffsetDateTime::UNIX_EPOCH.format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(OffsetDateTime::UNIX_EPOCH.format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(OffsetDateTime::UNIX_EPOCH.format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(OffsetDateTime::UNIX_EPOCH.format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(OffsetDateTime::UNIX_EPOCH.format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(OffsetDateTime::UNIX_EPOCH.format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(OffsetDateTime::UNIX_EPOCH.format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(datetime!(2021-001 0:00:00.1 UTC).format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(datetime!(2021-001 0:00:00.1 UTC).format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(datetime!(2021-001 0:00 +0:01).format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(datetime!(2021-001 0:00 +0:01).format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(datetime!(2021-001 0:00 +0:01).format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(datetime!(2021-001 0:00 +0:01).format_into_fmt_writer(&mut TestWriter, &Rfc3339));
+    assert_err(Time::MIDNIGHT.format_into_fmt_writer(&mut TestWriter, fd!("[hour padding:space]")));
+    assert_err(Time::MIDNIGHT.format_into_fmt_writer(&mut TestWriter, fd!("[hour padding:space]")));
+    assert_err(
+        offset!(+1).format_into_fmt_writer(&mut TestWriter, fd!("[offset_hour sign:mandatory]")),
+    );
+    assert_err(offset!(-1).format_into_fmt_writer(&mut TestWriter, fd!("[offset_hour]")));
+    assert_err(offset!(-1).format_into_fmt_writer(&mut TestWriter, fd!("[offset_hour]")));
+    assert_err(date!(-1 - 001).format_into_fmt_writer(&mut TestWriter, fd!("[year]")));
+    assert_err(
+        date!(2021 - 001).format_into_fmt_writer(&mut TestWriter, fd!("[year sign:mandatory]")),
+    );
+    assert_err(date!(+999_999 - 001).format_into_fmt_writer(&mut TestWriter, fd!("[year]")));
+    assert_err(date!(+99_999 - 001).format_into_fmt_writer(&mut TestWriter, fd!("[year]")));
+
+    let component_names = [
+        "day",
+        "month",
+        "ordinal",
+        "weekday",
+        "week_number",
+        "year",
+        "hour",
+        "minute",
+        "period",
+        "second",
+        "subsecond",
+        "offset_hour",
+        "offset_minute",
+        "offset_second",
+    ];
+    for component in &component_names {
+        assert_err(OffsetDateTime::UNIX_EPOCH.format_into_fmt_writer(
+            &mut TestWriter,
+            &format_description::parse(&format!("[{}]", component))?,
+        ));
+    }
+
+    Ok(())
+}
+
 #[test]
 fn first() -> time::Result<()> {
     assert_eq!(Time::MIDNIGHT.format(&FormatItem::First(&[]))?, "");

From 9c520afc6e2165c491af9395e981ad673102840c Mon Sep 17 00:00:00 2001
From: Mathspy <mathspy257@gmail.com>
Date: Mon, 3 Jan 2022 12:58:53 +0200
Subject: [PATCH 09/12] Add tests for new error source and display

---
 tests/integration/error.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/integration/error.rs b/tests/integration/error.rs
index b632e6b97..c07d9ffaa 100644
--- a/tests/integration/error.rs
+++ b/tests/integration/error.rs
@@ -1,6 +1,6 @@
 use std::convert::TryFrom;
 use std::error::Error as _;
-use std::io;
+use std::{fmt, io};
 
 use time::error::{
     ComponentRange, ConversionRange, DifferentVariant, Error, Format, IndeterminateOffset,
@@ -108,6 +108,7 @@ fn display() {
         Error::from(invalid_format_description())
     );
     assert_display_eq!(io_error(), Format::from(io_error()));
+    assert_display_eq!(fmt::Error, Format::from(fmt::Error));
     assert_display_eq!(DifferentVariant, Error::from(DifferentVariant));
 }
 
@@ -144,6 +145,7 @@ fn source() {
         InvalidFormatDescription
     );
     assert_source!(Format::from(io_error()), io::Error);
+    assert_source!(Format::from(fmt::Error), fmt::Error);
     assert_source!(Error::from(DifferentVariant), DifferentVariant);
 }
 

From 367f8a623d5980d409809b024485bf82b5797adb Mon Sep 17 00:00:00 2001
From: Mathspy <mathspy257@gmail.com>
Date: Mon, 3 Jan 2022 23:21:03 +0200
Subject: [PATCH 10/12] Add failing test for handling invalid utf8

---
 tests/integration/formatting.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/integration/formatting.rs b/tests/integration/formatting.rs
index 777b51b83..2d79ac6b4 100644
--- a/tests/integration/formatting.rs
+++ b/tests/integration/formatting.rs
@@ -599,3 +599,13 @@ fn first() -> time::Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn format_into_invalid_utf8() -> time::Result<()> {
+    let mut bytes = Vec::new();
+    let bytes_written = Time::MIDNIGHT.format_into(&mut bytes, &FormatItem::Literal(&[195, 40]))?;
+    assert_eq!(bytes, vec![195, 40]);
+    assert_eq!(bytes_written, 2);
+
+    Ok(())
+}

From 485ede8de73e48392f0547acc0afb129b143c1f7 Mon Sep 17 00:00:00 2001
From: Mathspy <mathspy257@gmail.com>
Date: Mon, 3 Jan 2022 23:30:21 +0200
Subject: [PATCH 11/12] Refactor compatibility functionality into Compat
 methods

---
 src/formatting/formattable.rs | 39 +++++++++++++++++++++++------------
 1 file changed, 26 insertions(+), 13 deletions(-)

diff --git a/src/formatting/formattable.rs b/src/formatting/formattable.rs
index e973c58de..1d9b71495 100644
--- a/src/formatting/formattable.rs
+++ b/src/formatting/formattable.rs
@@ -44,6 +44,29 @@ where
     }
 }
 
+impl<'a, W> Compat<'a, W>
+where
+    W: io::Write,
+{
+    /// Create the compatibility layer from this [`io::Write`]
+    fn from_io(writer: &'a mut W) -> Self {
+        Self {
+            writer,
+            bytes_written: 0,
+            error: None,
+        }
+    }
+
+    /// Turn a `Result<(), error::Format::StdFmt>` into `Result<usize, error::Format::StdIo>`
+    fn into_io_result(self, result: Result<(), error::Format>) -> Result<usize, error::Format> {
+        result.map(|_| self.bytes_written).map_err(|fmt_error| {
+            self.error
+                .map(error::Format::from)
+                .unwrap_or_else(|| fmt_error)
+        })
+    }
+}
+
 /// Seal the trait to prevent downstream users from implementing it.
 mod sealed {
     #[allow(clippy::wildcard_imports)]
@@ -69,19 +92,9 @@ mod sealed {
             time: Option<Time>,
             offset: Option<UtcOffset>,
         ) -> Result<usize, error::Format> {
-            let mut compat = Compat {
-                writer: output,
-                bytes_written: 0,
-                error: None,
-            };
-            self.format_into(&mut compat, date, time, offset)
-                .map(|_| compat.bytes_written)
-                .map_err(|fmt_error| {
-                    compat
-                        .error
-                        .map(error::Format::from)
-                        .unwrap_or_else(|| fmt_error)
-                })
+            let mut compat = Compat::from_io(output);
+            let result = self.format_into(&mut compat, date, time, offset);
+            compat.into_io_result(result)
         }
 
         /// Format the item directly to a `String`.

From 959bb7399d3befee840af6f0338a886e87615468 Mon Sep 17 00:00:00 2001
From: Mathspy <mathspy257@gmail.com>
Date: Mon, 3 Jan 2022 23:30:50 +0200
Subject: [PATCH 12/12] Special handle `io::Write` with `FormatItem::Literal`
 behavior

---
 src/formatting/formattable.rs | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/formatting/formattable.rs b/src/formatting/formattable.rs
index 1d9b71495..c4f9d36f9 100644
--- a/src/formatting/formattable.rs
+++ b/src/formatting/formattable.rs
@@ -135,6 +135,26 @@ impl<'a> sealed::Sealed for FormatItem<'a> {
 
         Ok(())
     }
+
+    fn format_into_old(
+        &self,
+        output: &mut impl io::Write,
+        date: Option<Date>,
+        time: Option<Time>,
+        offset: Option<UtcOffset>,
+    ) -> Result<usize, error::Format> {
+        match self {
+            Self::Literal(literal) => {
+                output.write_all(literal)?;
+                Ok(literal.len())
+            }
+            other => {
+                let mut compat = Compat::from_io(output);
+                let result = other.format_into(&mut compat, date, time, offset);
+                compat.into_io_result(result)
+            }
+        }
+    }
 }
 
 impl<'a> sealed::Sealed for [FormatItem<'a>] {