rustfmt fails to format a specific match statement

[rgeorgiev583]

I couldn't manage to isolate the specific bug in this case, so I'm going to provide the definition of the function containing the match statement as-is:

#[derive(Debug)]
enum Error<'a> {
    RuntimeError(&'a str),
    IoError(io::Error),
}

impl<'a> std::error::Error for Error<'a> {
    fn source(&self) -> Option<&(std::error::Error + 'static)> {
        match self {
            Error::IoError(error) => Some(error),
            _ => None,
        }
    }
}

impl<'a> Display for Error<'a> {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        match self {
            Error::RuntimeError(description) => write!(f, "runtime error: {}", description),
            Error::IoError(error) => write!(f, "I/O error: {}", error),
        }
    }
}

impl<'a> From<std::io::Error> for Error<'a> {
    fn from(error: io::Error) -> Self {
        Error::IoError(error)
    }
}

type Result<'a, T> = std::result::Result<T, Error<'a>>;

enum Value {
    Str(String),
    Bool(bool),
    Number(Float),
}

impl Display for Value {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        match self {
            Value::Str(value) => write!(f, "{}", value),
            Value::Bool(value) => write!(f, "{}", value),
            Value::Number(value) => write!(f, "{}", value),
        }
    }
}

enum InputMode {
    Disabled,
    Simple(String),
    Nested(usize, String),
}

struct State {
    stack: Vec<Value>,
    input_mode: InputMode,
}

enum ArithmeticOperation {
    Addition,
    Subtraction,
    Multiplication,
    Division,
    Remainder,
}

fn apply_arithmetic_operation<'a>(op: ArithmeticOperation, state: &mut State) -> Result<'a, ()> {
    match       (       state.stack.pop           (),       state.stack.pop      ()                   )





    {
                    (Some(value1), Some(value2)) => {



                        match (value1, value2) {
                        (Value::Number(num1), Value::Number(num2)) => {
                            let result = match op {
                                ArithmeticOperation::Addition => num1 + num2,
                                ArithmeticOperation::Subtraction => num1 - num2,
                                ArithmeticOperation::Multiplication => num1 * num2,
                                    ArithmeticOperation::Division => num1 /num2,
                                ArithmeticOperation::Remainder => num1 % num2,
                            };
                            state.stack.push(Value::Number(result));
                            Ok(())
                        }
                        _ =>
                    Err(Error::RuntimeError(
                        "cannot sum values on top of stack: the two topmost values on the stack should be numbers",
                    ))
                    }}
                    _ =>
                                                return Err(Error::RuntimeError(
                        "cannot sum values on top of stack: there must be at least two values on the stack",
                    ))
                }
}

rustfmt seems to properly format that except for the whole outermost match statement where the whitespace still remains garbled.

[topecongiro]

A smaller example:

fn foo(input: Option<usize>) -> usize {
    match x {
                _ =>
                    Err(Error::RuntimeError(
                        "cannot sum values on top of stack: the two topmost values on the stack should be numbers",
                    ))
            }
}

Looks like rustfmt fails to format the entire match expression because of the string literal that exceeds max width. @rgeorgiev583 To work around this for now, please make the string literal shorter manually or by setting wrap_str = true to rustfmt.toml (though the configuration option is kind of buggish).

[rgeorgiev583]

@topecongiro
I split the string literal manually and rustfmt now seems to format everything correctly.
The workaround with wrap_str = true did not work for me, though (rustfmt seems to ignore that option as it is not present in rustfmt --help=config at all).
Anyway, thanks for the suggestion because it solved my issue!

[scampi]

@rgeorgiev583 there is also the option format_strings that would split the long string for you.

[scampi]

@topecongiro did you mean format_strings instead of wrap_str ?