1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use crate::ast::utils;
use crate::ast::{CloseBrace, Comma, Expr, If, Match, OpenBrace, Pat, Rocket};
use crate::error::{ParseError, Result};
use crate::parser::Parser;
use crate::traits::Parse;
use runestick::unit::Span;

/// A match branch.
#[derive(Debug, Clone)]
pub struct ExprMatchBranch {
    /// The pattern to match.
    pub pat: Pat,
    /// The branch condition.
    pub condition: Option<(If, Box<Expr>)>,
    /// The rocket token.
    pub rocket: Rocket,
    /// The body of the match.
    pub body: Box<Expr>,
}

impl ExprMatchBranch {
    /// Access the span of the expression.
    pub fn span(&self) -> Span {
        self.pat.span().join(self.body.span())
    }

    /// Test if the branch produces nothing.
    pub fn produces_nothing(&self) -> bool {
        self.body.produces_nothing()
    }
}

/// Parse a match statement.
///
/// # Examples
///
/// ```rust
/// use rune::{ParseAll, parse_all, ast};
///
/// # fn main() -> rune::Result<()> {
/// parse_all::<ast::ExprMatchBranch>("1 => { foo }")?;
/// # Ok(())
/// # }
/// ```
impl Parse for ExprMatchBranch {
    fn parse(parser: &mut Parser) -> Result<Self, ParseError> {
        let pat = parser.parse()?;

        let condition = if parser.peek::<If>()? {
            Some((parser.parse()?, Box::new(parser.parse()?)))
        } else {
            None
        };

        Ok(Self {
            pat,
            condition,
            rocket: parser.parse()?,
            body: Box::new(parser.parse()?),
        })
    }
}

/// A match expression.
#[derive(Debug, Clone)]
pub struct ExprMatch {
    /// The `match` token.
    pub match_: Match,
    /// The expression who's result we match over.
    pub expr: Box<Expr>,
    /// The open brace of the match.
    pub open: OpenBrace,
    /// Branches.
    pub branches: Vec<(ExprMatchBranch, Option<Comma>)>,
    /// The close brace of the match.
    pub close: CloseBrace,
}

impl ExprMatch {
    /// Access the span of the expression.
    pub fn span(&self) -> Span {
        self.match_.span().join(self.close.span())
    }
}

/// Parse a match statement.
///
/// # Examples
///
/// ```rust
/// use rune::{ParseAll, parse_all, ast};
///
/// # fn main() -> rune::Result<()> {
/// parse_all::<ast::ExprMatch>("match 0 { _ => 1, }")?;
/// # Ok(())
/// # }
/// ```
impl Parse for ExprMatch {
    fn parse(parser: &mut Parser) -> Result<Self, ParseError> {
        let match_ = parser.parse()?;
        let expr = Box::new(Expr::parse_without_eager_brace(parser)?);

        let open = parser.parse()?;

        let mut branches = Vec::new();

        while !parser.peek::<CloseBrace>()? {
            let branch = parser.parse::<ExprMatchBranch>()?;

            let comma = if parser.peek::<Comma>()? {
                Some(parser.parse()?)
            } else {
                None
            };

            let is_end = utils::is_block_end(&*branch.body, comma.as_ref());
            branches.push((branch, comma));

            if is_end {
                break;
            }
        }

        let close = parser.parse()?;

        Ok(ExprMatch {
            match_,
            expr,
            open,
            branches,
            close,
        })
    }
}