logparse/

spans.rs

use super::ast::*;
use std::borrow::Cow;

/// Text categories, based on the parsing.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum SpanKind {
    /// Parentheses e.g.
    ///
    /// Stores the delimiter depth, for e.g. rainbow delimiters.
    Delimiter(usize),
    /// Separators like `=`, ':' and ','
    Separator,
    /// Numbers
    Number,
    /// Known literals, like `true`, `false`, `None`, `Ok`, `Err`
    Literal,
    /// Lifetimes (`'foo`)
    Lifetime,
    /// Strings
    String,
    /// Paths
    Path,
    /// Spaces (returns original number of spaces)
    Space(usize),

    /// Constructor: the prefix of a delimited block.
    /// i.e. `Some` in `Some(3)`
    Constructor,

    /// String prefix, suffix, hashtags, etc.
    /// Also number suffix
    Surroundings,

    /// Any other text (the default)
    Text,
}

/// A `Span` is a piece of categorized text, based on the parsing done by
/// [`parse_input`](crate::parse_input).
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct Span<'a> {
    /// The segment of text.
    pub text: Cow<'a, str>,
    /// Its category.
    pub kind: SpanKind,
}

/// Configuration options for [`into_spans`]
pub struct Config {
    /// Turn sequences of more than 1 space into exactly 1 space.
    pub collapse_space: bool,
}

pub trait IntoSpans<'a>: private::IntoSpansImpl<'a> {}

/// Turn an ast node into [`Span`]s.
pub fn into_spans<'a>(ast: impl IntoSpans<'a>, config: Config) -> Vec<Span<'a>> {
    let mut cx = private::Context {
        config,
        res: Vec::new(),
        depth: 0,
    };
    ast.into_spans(&mut cx);
    cx.res
}

mod private {
    use super::*;

    pub struct Context<'a> {
        pub config: Config,
        pub res: Vec<Span<'a>>,
        pub depth: usize,
    }

    impl<'a> Context<'a> {
        fn push(&mut self, text: impl Into<Cow<'a, str>>, kind: SpanKind) {
            self.res.push(Span {
                text: text.into(),
                kind,
            })
        }
    }

    pub trait IntoSpansImpl<'a> {
        fn into_spans(self, cx: &mut Context<'a>);
    }

    impl<'a, T> IntoSpans<'a> for T where T: IntoSpansImpl<'a> {}

    impl<'a> IntoSpansImpl<'a> for Separator {
        fn into_spans(self, cx: &mut Context<'a>) {
            match self {
                Separator::Eq => cx.push("=", SpanKind::Separator),
                Separator::Colon => cx.push(":", SpanKind::Separator),
                Separator::DoubleColon => cx.push("::", SpanKind::Separator),
            }
        }
    }

    impl<'a> IntoSpansImpl<'a> for QuoteType {
        fn into_spans(self, cx: &mut Context<'a>) {
            match self {
                QuoteType::Single => cx.push("'", SpanKind::Separator),
                QuoteType::Double => cx.push("\"", SpanKind::Separator),
                QuoteType::Backtick => cx.push("`", SpanKind::Separator),
            }
        }
    }

    impl<'a> IntoSpansImpl<'a> for AnyString<'a> {
        fn into_spans(self, cx: &mut Context<'a>) {
            let Self {
                prefix,
                ty,
                contents,
                num_hashtags,
                suffix,
            } = self;
            cx.push(prefix, SpanKind::Surroundings);
            for _ in 0..num_hashtags {
                cx.push("#", SpanKind::Surroundings)
            }

            ty.into_spans(cx);
            cx.push(contents, SpanKind::String);
            ty.into_spans(cx);

            for _ in 0..num_hashtags {
                cx.push("#", SpanKind::Surroundings)
            }
            cx.push(suffix, SpanKind::Surroundings);
        }
    }

    impl<'a> IntoSpansImpl<'a> for Path<'a> {
        fn into_spans(self, cx: &mut Context<'a>) {
            cx.push(self.to_string(), SpanKind::Path)
        }
    }

    impl<'a> IntoSpansImpl<'a> for Number<'a> {
        fn into_spans(self, cx: &mut Context<'a>) {
            cx.push(self.number, SpanKind::Number);

            if let Some(suffix) = self.suffix_without_underscore {
                cx.push("_", SpanKind::Surroundings);
                cx.push(suffix, SpanKind::Surroundings);
            }
        }
    }

    impl<'a> IntoSpansImpl<'a> for Atom<'a> {
        fn into_spans(self, cx: &mut Context<'a>) {
            match self {
                Atom::Text(text) => cx.push(text, SpanKind::Text),
            }
        }
    }

    impl<'a> IntoSpansImpl<'a> for Space<'a> {
        fn into_spans(self, cx: &mut Context<'a>) {
            match self.0.len() {
                0 => {}
                1 => cx.push(self.0, SpanKind::Space(1)),
                n if cx.config.collapse_space => cx.push(" ", SpanKind::Space(n)),
                n => cx.push(self.0, SpanKind::Space(n)),
            }
        }
    }

    impl<'a> IntoSpansImpl<'a> for Token<'a> {
        fn into_spans(self, cx: &mut Context<'a>) {
            match self {
                Token::True => cx.push("true", SpanKind::Literal),
                Token::False => cx.push("false", SpanKind::Literal),
                Token::None => cx.push("None", SpanKind::Literal),
                Token::Path(path) => path.into_spans(cx),
                Token::String(string) => string.into_spans(cx),
                Token::Number(number) => number.into_spans(cx),
                Token::Separated {
                    before,
                    space_before,
                    separator,
                    after,
                } => {
                    before.into_spans(cx);
                    space_before.into_spans(cx);
                    separator.into_spans(cx);
                    after.into_spans(cx);
                }
                Token::Delimited(delimited) => {
                    delimited.into_spans(cx);
                }
                Token::Atom(atom) => {
                    atom.into_spans(cx);
                }
                Token::Lifetime(lifetime) => {
                    cx.push("'", SpanKind::Surroundings);
                    cx.push(lifetime, SpanKind::Lifetime);
                }
            }
        }
    }

    impl<'a> IntoSpansImpl<'a> for Segment<'a> {
        fn into_spans(self, cx: &mut Context<'a>) {
            let Self {
                leading_space,
                token,
            } = self;
            leading_space.into_spans(cx);
            token.into_spans(cx);
        }
    }

    impl<'a> IntoSpansImpl<'a> for Segments<'a> {
        fn into_spans(self, cx: &mut Context<'a>) {
            let Self {
                segments,
                trailing_space,
            } = self;
            for segment in segments {
                segment.into_spans(cx);
            }
            trailing_space.into_spans(cx);
        }
    }

    impl<'a> IntoSpansImpl<'a> for Delimited<'a> {
        fn into_spans(self, cx: &mut Context<'a>) {
            let Self {
                prefix,
                delimiter,
                contents,
            } = self;

            match prefix {
                Some((Atom::Text(text), space)) => {
                    cx.push(
                        text,
                        match delimiter {
                            Delimiter::Brace => SpanKind::Constructor,
                            Delimiter::Paren if space.0.is_empty() => SpanKind::Constructor,
                            Delimiter::Paren => SpanKind::Text,
                            Delimiter::Bracket => SpanKind::Text,
                            Delimiter::Angle if space.0.is_empty() => SpanKind::Constructor,
                            Delimiter::Angle => SpanKind::Text,
                        },
                    );
                    space.into_spans(cx);
                }
                None => {}
            }

            match delimiter {
                Delimiter::Paren => cx.push("(", SpanKind::Delimiter(cx.depth)),
                Delimiter::Bracket => cx.push("[", SpanKind::Delimiter(cx.depth)),
                Delimiter::Brace => cx.push("{", SpanKind::Delimiter(cx.depth)),
                Delimiter::Angle => cx.push("<", SpanKind::Delimiter(cx.depth)),
            }

            cx.depth += 1;
            contents.into_spans(cx);
            cx.depth -= 1;

            match delimiter {
                Delimiter::Paren => cx.push(")", SpanKind::Delimiter(cx.depth)),
                Delimiter::Bracket => cx.push("]", SpanKind::Delimiter(cx.depth)),
                Delimiter::Brace => cx.push("}", SpanKind::Delimiter(cx.depth)),
                Delimiter::Angle => cx.push(">", SpanKind::Delimiter(cx.depth)),
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use insta::assert_debug_snapshot;

    use super::SpanKind;
    use crate::{Config, into_spans, parse_input};

    fn spans(input: &str) -> Vec<(String, SpanKind)> {
        let res = parse_input(input).unwrap();
        into_spans(
            res,
            Config {
                collapse_space: true,
            },
        )
        .into_iter()
        .map(|i| (i.text.into_owned(), i.kind))
        .collect()
    }

    #[test]
    fn spans_ex1() {
        assert_debug_snapshot!(spans(
            r#"def_id=DefId(0:3 ~ unsized_coercion[10fa]::Trait)"#
        ), @r#"
        [
            (
                "def_id",
                Text,
            ),
            (
                "=",
                Separator,
            ),
            (
                "DefId",
                Constructor,
            ),
            (
                "(",
                Delimiter(
                    0,
                ),
            ),
            (
                "0",
                Number,
            ),
            (
                ":",
                Separator,
            ),
            (
                "3",
                Number,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "~",
                Text,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "unsized_coercion",
                Text,
            ),
            (
                "[",
                Delimiter(
                    1,
                ),
            ),
            (
                "10fa",
                Text,
            ),
            (
                "]",
                Delimiter(
                    1,
                ),
            ),
            (
                "::",
                Separator,
            ),
            (
                "Trait",
                Text,
            ),
            (
                ")",
                Delimiter(
                    0,
                ),
            ),
        ]
        "#)
    }

    #[test]
    fn spans_ex2() {
        assert_debug_snapshot!(spans(
            r#"data=TypeNs("MetaSized") visible_parent=DefId(2:3984 ~ core[bcc4]::marker) actual_parent=Some(DefId(2:3984 ~ core[bcc4]::marker))"#
        ), @r#"
        [
            (
                "data",
                Text,
            ),
            (
                "=",
                Separator,
            ),
            (
                "TypeNs",
                Constructor,
            ),
            (
                "(",
                Delimiter(
                    0,
                ),
            ),
            (
                "",
                Surroundings,
            ),
            (
                "\"",
                Separator,
            ),
            (
                "MetaSized",
                String,
            ),
            (
                "\"",
                Separator,
            ),
            (
                "",
                Surroundings,
            ),
            (
                ")",
                Delimiter(
                    0,
                ),
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "visible_parent",
                Text,
            ),
            (
                "=",
                Separator,
            ),
            (
                "DefId",
                Constructor,
            ),
            (
                "(",
                Delimiter(
                    0,
                ),
            ),
            (
                "2",
                Number,
            ),
            (
                ":",
                Separator,
            ),
            (
                "3984",
                Number,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "~",
                Text,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "core",
                Text,
            ),
            (
                "[",
                Delimiter(
                    1,
                ),
            ),
            (
                "bcc4",
                Text,
            ),
            (
                "]",
                Delimiter(
                    1,
                ),
            ),
            (
                "::",
                Separator,
            ),
            (
                "marker",
                Text,
            ),
            (
                ")",
                Delimiter(
                    0,
                ),
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "actual_parent",
                Text,
            ),
            (
                "=",
                Separator,
            ),
            (
                "Some",
                Constructor,
            ),
            (
                "(",
                Delimiter(
                    0,
                ),
            ),
            (
                "DefId",
                Constructor,
            ),
            (
                "(",
                Delimiter(
                    1,
                ),
            ),
            (
                "2",
                Number,
            ),
            (
                ":",
                Separator,
            ),
            (
                "3984",
                Number,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "~",
                Text,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "core",
                Text,
            ),
            (
                "[",
                Delimiter(
                    2,
                ),
            ),
            (
                "bcc4",
                Text,
            ),
            (
                "]",
                Delimiter(
                    2,
                ),
            ),
            (
                "::",
                Separator,
            ),
            (
                "marker",
                Text,
            ),
            (
                ")",
                Delimiter(
                    1,
                ),
            ),
            (
                ")",
                Delimiter(
                    0,
                ),
            ),
        ]
        "#)
    }

    #[test]
    fn spans_ex3() {
        assert_debug_snapshot!(spans(
            r#"insert(DefId(0:4 ~ unsized_coercion[10fa]::{impl#0})): inserting TraitRef <u32 as Trait> into specialization graph"#
        ), @r#"
        [
            (
                "insert",
                Constructor,
            ),
            (
                "(",
                Delimiter(
                    0,
                ),
            ),
            (
                "DefId",
                Constructor,
            ),
            (
                "(",
                Delimiter(
                    1,
                ),
            ),
            (
                "0",
                Number,
            ),
            (
                ":",
                Separator,
            ),
            (
                "4",
                Number,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "~",
                Text,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "unsized_coercion",
                Text,
            ),
            (
                "[",
                Delimiter(
                    2,
                ),
            ),
            (
                "10fa",
                Text,
            ),
            (
                "]",
                Delimiter(
                    2,
                ),
            ),
            (
                "::",
                Separator,
            ),
            (
                "{",
                Delimiter(
                    2,
                ),
            ),
            (
                "impl#0",
                Text,
            ),
            (
                "}",
                Delimiter(
                    2,
                ),
            ),
            (
                ")",
                Delimiter(
                    1,
                ),
            ),
            (
                ")",
                Delimiter(
                    0,
                ),
            ),
            (
                ":",
                Separator,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "inserting",
                Text,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "TraitRef",
                Text,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "<",
                Delimiter(
                    0,
                ),
            ),
            (
                "u32",
                Text,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "as",
                Text,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "Trait",
                Text,
            ),
            (
                ">",
                Delimiter(
                    0,
                ),
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "into",
                Text,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "specialization",
                Text,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "graph",
                Text,
            ),
        ]
        "#)
    }

    #[test]
    fn spans_ex4() {
        assert_debug_snapshot!(spans(
        r#"inspecting def_id=DefId(3:662 ~ alloc[ef11]::boxed::Box) span=tests/ui/impl-trait/unsized_coercion.rs:12:15: 12:30 (#0)"#
        ), @r##"
        [
            (
                "inspecting",
                Text,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "def_id",
                Text,
            ),
            (
                "=",
                Separator,
            ),
            (
                "DefId",
                Constructor,
            ),
            (
                "(",
                Delimiter(
                    0,
                ),
            ),
            (
                "3",
                Number,
            ),
            (
                ":",
                Separator,
            ),
            (
                "662",
                Number,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "~",
                Text,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "alloc",
                Text,
            ),
            (
                "[",
                Delimiter(
                    1,
                ),
            ),
            (
                "ef11",
                Text,
            ),
            (
                "]",
                Delimiter(
                    1,
                ),
            ),
            (
                "::",
                Separator,
            ),
            (
                "boxed",
                Text,
            ),
            (
                "::",
                Separator,
            ),
            (
                "Box",
                Text,
            ),
            (
                ")",
                Delimiter(
                    0,
                ),
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "span",
                Text,
            ),
            (
                "=",
                Separator,
            ),
            (
                "tests/ui/impl-trait/unsized_coercion.rs:12:15",
                Path,
            ),
            (
                ":",
                Separator,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "12",
                Number,
            ),
            (
                ":",
                Separator,
            ),
            (
                "30",
                Number,
            ),
            (
                " ",
                Space(
                    1,
                ),
            ),
            (
                "(",
                Delimiter(
                    0,
                ),
            ),
            (
                "#0",
                Text,
            ),
            (
                ")",
                Delimiter(
                    0,
                ),
            ),
        ]
        "##)
    }
}