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)]
7pub struct ParenthesizedPattern {
8 pub open_paren: Token,
9 pub pattern: Pattern,
10 pub close_paren: Token,
11 pub span: Span,
12}
13
14impl Spanned for ParenthesizedPattern {
15 fn span(&self) -> Span {
16 self.span
17 }
18}
19
20impl ParenthesizedPattern {
21 pub(crate) fn finish(
22 parser: &mut Parser,
23 open_paren: Token,
24 pattern: Pattern,
25 ) -> SyntaxResult<Self> {
26 let close_paren = parser
27 .expect(CParen)
28 .map_err(|token| parser.expected(token, "expected `)`"))?;
29 Ok(Self {
30 span: open_paren.span.union(close_paren.span()),
31 open_paren,
32 pattern,
33 close_paren,
34 })
35 }
36
37 pub(crate) fn parse(parser: &mut Parser) -> SyntaxResult<Self> {
38 let open_paren = parser
39 .expect(OParen)
40 .map_err(|token| parser.expected(token, "expected `(`"))?;
41 let pattern = Pattern::parse(parser)?;
42 Self::finish(parser, open_paren, pattern)
43 }
44}
45
46impl TryFrom<ParenthesizedExpression> for ParenthesizedPattern {
47 type Error = SyntaxError;
48
49 fn try_from(value: ParenthesizedExpression) -> Result<Self, Self::Error> {
50 Ok(Self {
51 span: value.span,
52 open_paren: value.open_paren,
53 pattern: value.expression.try_into()?,
54 close_paren: value.close_paren,
55 })
56 }
57}