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 SetLiteral {
8 pub open_bracket_pipe: Token,
9 pub elements: Vec<SetElement>,
10 pub close_bracket_pipe: Token,
11}
12
13impl Spanned for SetLiteral {
14 fn span(&self) -> Span {
15 self.open_bracket_pipe
16 .span
17 .union(self.close_bracket_pipe.span)
18 }
19}
20
21impl SetLiteral {
22 pub(crate) fn new_empty(open_bracket_pipe: Token, close_bracket_pipe: Token) -> Self {
23 Self {
24 open_bracket_pipe,
25 elements: vec![],
26 close_bracket_pipe,
27 }
28 }
29
30 pub(crate) fn parse_rest(
31 parser: &mut Parser,
32 open_bracket_pipe: Token,
33 first: SetElement,
34 ) -> SyntaxResult<Result<Self, SetPattern>> {
35 let mut elements = vec![first];
36 if let Ok(close_bracket_pipe) = parser.expect(CBrackPipe) {
37 return Ok(Ok(Self {
38 open_bracket_pipe,
39 elements,
40 close_bracket_pipe,
41 }));
42 };
43 let close_bracket_pipe = loop {
44 parser.expect(OpComma).map_err(|token| {
45 parser.expected(token, "expected `|]` to end or `,` to continue set literal")
46 })?;
47 if let Ok(close_bracket_pipe) = parser.expect(CBrackPipe) {
48 break close_bracket_pipe;
49 };
50 match SetElement::parse(parser)? {
51 Ok(element) => elements.push(element),
52 Err(next) => {
53 return Ok(Err(SetPattern::parse_from_expression(
54 parser,
55 open_bracket_pipe,
56 elements,
57 next,
58 )?));
59 }
60 }
61 if let Ok(token) = parser.check(KwFor) {
62 let error = SyntaxError::new(
63 token.span,
64 "only one element may precede the `for` keyword in a comprehension",
65 );
66 parser.error(error.clone());
67 return Err(error);
68 }
69 if let Ok(close_bracket_pipe) = parser.expect(CBrackPipe) {
70 break close_bracket_pipe;
71 };
72 };
73 Ok(Ok(Self {
74 open_bracket_pipe,
75 elements,
76 close_bracket_pipe,
77 }))
78 }
79
80 pub fn start_token(&self) -> &Token {
81 &self.open_bracket_pipe
82 }
83
84 pub fn end_token(&self) -> &Token {
85 &self.close_bracket_pipe
86 }
87}
88
89#[derive(Clone, Debug, Spanned, PrettyPrintSExpr)]
90pub enum SetElement {
91 Element(Expression),
92 Spread(Token, Expression),
93}
94
95impl SetElement {
96 pub(crate) fn parse(
97 parser: &mut Parser,
98 ) -> SyntaxResult<Result<Self, (Option<Token>, Pattern)>> {
99 let spread = parser.expect(OpDotDot).ok();
100 if let Some(spread) = &spread
101 && let Ok(dot) = parser.expect(OpDot)
102 {
103 parser.error(ErrorKind::TripleDot { dot: dot.span }.at(spread.span));
104 }
105 let expression = Expression::parse_parameter_list(parser)?;
106 match expression {
107 Ok(expression) => match spread {
108 None => Ok(Ok(Self::Element(expression))),
109 Some(spread) => Ok(Ok(Self::Spread(spread, expression))),
110 },
111 Err(pattern) => Ok(Err((spread, pattern))),
112 }
113 }
114}