Compiler Explorer

Source code

use std::mem;

macro_rules! assume_unreachable {
    () => {
        loop {}
    };
}

pub trait uWrite {
    /// The error associated to this writer
    type Error;

/// Writes a string slice into this writer, returning whether the write succeeded.
    ///
    /// This method can only succeed if the entire string slice was successfully written, and this
    /// method will not return until all data has been written or an error occurs.
    fn write_str(&mut self, s: &str) -> Result<(), Self::Error>;

/// Writes a [`char`] into this writer, returning whether the write succeeded.
    ///
    /// A single [`char`] may be encoded as more than one byte. This method can only succeed if the
    /// entire byte sequence was successfully written, and this method will not return until all
    /// data has been written or an error occurs.
    fn write_char(&mut self, c: char) -> Result<(), Self::Error> {
        let mut buf: [u8; 4] = unsafe { mem::uninitialized() };
        self.write_str(c.encode_utf8(&mut buf))
    }
}

#[allow(non_camel_case_types)]
pub struct Formatter<'w, W>
where
    W: uWrite + ?Sized,
{
    indentation: u8,
    pretty: bool,
    writer: &'w mut W,
}

impl<'w, W> Formatter<'w, W>
where
    W: uWrite + ?Sized,
{
    /// Creates a formatter from the given writer
    pub fn new(writer: &'w mut W) -> Self {
        Self {
            indentation: 0,
            pretty: false,
            writer,
        }
    }

/// Execute the closure with pretty-printing enabled
    pub fn pretty(
        &mut self,
        f: impl FnOnce(&mut Self) -> Result<(), W::Error>,
    ) -> Result<(), W::Error> {
        let pretty = self.pretty;
        self.pretty = true;
        f(self)?;
        self.pretty = pretty;
        Ok(())
    }

/// Writes a character to the underlying buffer contained within this formatter.
    pub fn write_char(&mut self, c: char) -> Result<(), W::Error> {
        self.writer.write_char(c)
    }

/// Writes a string slice to the underlying buffer contained within this formatter.
    pub fn write_str(&mut self, s: &str) -> Result<(), W::Error> {
        self.writer.write_str(s)
    }

/// Write whitespace according to the current `self.indentation`
    fn indent(&mut self) -> Result<(), W::Error> {
        for _ in 0..self.indentation {
            self.write_str("    ")?;
        }

Ok(())
    }
}

trait uDebug {
    fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
    where
        W: uWrite + ?Sized;
}

impl uDebug for str {
    fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>
    where
        W: uWrite + ?Sized,
    {
        f.write_str("\"")?;

let mut from = 0;
        for (i, c) in self.char_indices() {
            let esc = c.escape_debug();

// If char needs escaping, flush backlog so far and write, else skip
            if esc.len() != 1 {
                f.write_str(
                    self.get(from..i)
                        .unwrap_or_else(|| unsafe { assume_unreachable!() }),
                )?;
                for c in esc {
                    f.write_char(c)?;
                }
                from = i + c.len_utf8();
            }
        }

f.write_str(
            self.get(from..)
                .unwrap_or_else(|| unsafe { assume_unreachable!() }),
        )?;
        f.write_str("\"")
    }
}

pub struct Foo;
impl uWrite for Foo {
    type Error = ();

fn write_str(&mut self, s: &str) -> Result<(), ()> {
        Ok(())
    }
}

pub fn debug_str(f: &mut Formatter<'_, Foo>, s: &str) {
    s.fmt(f);
}