eldridge.cam
Actually just three programming languages in a trenchcoat
1use super::*;
2use crate::{Parser, Spanned};
3use source_span::Span;
4use trilogy_scanner::{Token, TokenType::*};
5
6#[derive(Clone, Debug, PrettyPrintSExpr)]
7pub struct ParenthesizedPattern {
8 pub open_paren: Token,
9 pub pattern: Pattern,
10 pub close_paren: Token,
11}
12
13impl Spanned for ParenthesizedPattern {
14 fn span(&self) -> Span {
15 self.open_paren.span.union(self.close_paren.span())
16 }
17}
18
19impl ParenthesizedPattern {
20 pub(crate) fn finish(
21 parser: &mut Parser,
22 open_paren: Token,
23 pattern: Pattern,
24 ) -> SyntaxResult<Self> {
25 let close_paren = parser
26 .expect(CParen)
27 .map_err(|token| parser.expected(token, "expected `)`"))?;
28 Ok(Self {
29 open_paren,
30 pattern,
31 close_paren,
32 })
33 }
34
35 pub(crate) fn parse(parser: &mut Parser) -> SyntaxResult<Self> {
36 let open_paren = parser
37 .expect(OParen)
38 .map_err(|token| parser.expected(token, "expected `(`"))?;
39 let pattern = Pattern::parse(parser)?;
40 Self::finish(parser, open_paren, pattern)
41 }
42}
43
44impl TryFrom<ParenthesizedExpression> for ParenthesizedPattern {
45 type Error = SyntaxError;
46
47 fn try_from(value: ParenthesizedExpression) -> Result<Self, Self::Error> {
48 Ok(Self {
49 open_paren: value.open_paren,
50 pattern: value.expression.try_into()?,
51 close_paren: value.close_paren,
52 })
53 }
54}