Don't split input over multiple lines in debug view.

[aDotInTheVoid]

If the Input type is a slice, using {:#?} will insert newlines into
the debug view. This messes up the output, which is counting charecters
to fill a single line.

Before:

> alt                                                      | [
    Call @ 0..4,
    Ident
 > separated_foldl1                                        | [
    Call @ 0..4,
    Ident
  > separated_foldl1                                       | [
    Call @ 0..4,
    Ident
   > separated_foldl1                                      | [
    Call @ 0..4,
    Ident
    > separated_foldl1                                     | [
    Call @ 0..4,
    Ident
     > separated_foldl1                                    | [
    Call @ 0..4,
    Ident
      > separated_foldl1                                   | [
    Call @ 0..4,
    Ident
       > alt                                               | [
    Call @ 0..4,
    Ident
        > alt                                              | [
    Call @ 0..4,
    Ident
         > one_of                                          | [
    Call @ 0..4,
    Ident
          > any                                            | [
    Call @ 0..4,
    Ident

After:

> alt                                                      | [Call @ 0..4, Ident @ 5..19,
 > separated_foldl1                                        | [Call @ 0..4, Ident @ 5..19,
  > separated_foldl1                                       | [Call @ 0..4, Ident @ 5..19,
   > separated_foldl1                                      | [Call @ 0..4, Ident @ 5..19,
    > separated_foldl1                                     | [Call @ 0..4, Ident @ 5..19,
     > separated_foldl1                                    | [Call @ 0..4, Ident @ 5..19,
      > separated_foldl1                                   | [Call @ 0..4, Ident @ 5..19,
       > alt                                               | [Call @ 0..4, Ident @ 5..19,
        > alt                                              | [Call @ 0..4, Ident @ 5..19,
         > one_of                                          | [Call @ 0..4, Ident @ 5..19,
          > any                                            | [Call @ 0..4, Ident @ 5..19,

[epage]

We currently use the alternate debug form so our custom streams show a "nicer" view. We used this more in #514. #482 is discussing this further.

The main thing we could do is either

• Measure to the newline
• split off and only show the first line

[coveralls]

Pull Request Test Coverage Report for Build 8898483497

Details

• 0 of 1 (0.0%) changed or added relevant line in 1 file are covered.
• No unchanged relevant lines lost coverage.
• Overall coverage increased (+0.03%) to 41.61%

---

Changes Missing Coverage	Covered Lines	Changed/Added Lines	%
src/combinator/debug/internals.rs	0	1	0.0%

Totals
Change from base Build 8854777459:	0.03%
Covered Lines:	1277
Relevant Lines:	3069

---

💛 - Coveralls

[aDotInTheVoid]

Ah, (ab)using f.alterante() to switch input works

impl fmt::Debug for Input<'_, '_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if f.alternate() {
            let toks = self.remaining_input();
            // Don't use Debug::fmt(f, toks) to force non-alternate writing, see winnow#516
            write!(f, "{toks:?}")
        } else {
            f.debug_struct("Input")
                .field("source", &self.source)
                .field("offset", &self.offset)
                .field("acx", &self.acx)
                .finish()
        }
    }
}

(where .remaining_input() returns the slice still to be parsed).

It does unfortunatly mean that dbg!(i) won't show the offset, but I think it's a good tradeoff for me for now.

[aDotInTheVoid]

See also #482 (comment), for some thaughts on a potential change to Stream to make this easier