1use crate::Stmt;
2use anyhow::{Result, anyhow};
3use dynamic::Dynamic;
4use smol_str::SmolStr;
5
6use super::{Parser, ParserErr, Span, Type, try_parse};
7use num_enum::{FromPrimitive, IntoPrimitive};
8
9#[repr(i32)]
10#[derive(Debug, Clone, PartialEq, IntoPrimitive, FromPrimitive)]
11pub enum UnaryOp {
12 Neg = 0,
13 Not,
14 #[num_enum(default)]
15 Unknow = 255,
16}
17
18#[repr(i32)]
19#[derive(Debug, Clone, PartialEq, IntoPrimitive, FromPrimitive)]
20pub enum BinaryOp {
21 Add = 10,
22 Sub,
23 Mul,
24 Div,
25 Mod,
26 Shr,
27 Shl,
28 BitAnd,
29 BitOr,
30 BitXor,
31 AddAssign,
32 SubAssign,
33 MulAssign,
34 DivAssign,
35 ModAssign,
36 ShrAssign,
37 ShlAssign,
38 BitAndAssign,
39 BitOrAssign,
40 BitXorAssign,
41 Assign,
42 Eq,
43 Ne,
44 Lt,
45 Gt,
46 Le,
47 Ge,
48 And,
49 Or,
50 Idx,
51 RangeOpen,
52 RangeClose,
53 #[num_enum(default)]
54 Unknow = 255,
55}
56
57impl BinaryOp {
58 pub fn is_logic(&self) -> bool {
59 matches!(self, Self::And | Self::Or | Self::Eq | Self::Ne | Self::Lt | Self::Gt | Self::Le | Self::Ge)
60 }
61
62 pub fn is_add(&self) -> bool {
63 matches!(self, Self::Add | Self::AddAssign)
64 }
65
66 pub fn is_assign(&self) -> bool {
67 matches!(
68 self,
69 Self::AddAssign | Self::Assign | Self::DivAssign | Self::ModAssign | Self::MulAssign | Self::SubAssign | Self::BitAndAssign | Self::BitOrAssign | Self::BitXorAssign | Self::ShlAssign | Self::ShrAssign
70 )
71 }
72
73 pub fn weight(&self) -> usize {
74 match self {
75 Self::Idx => 30,
76 Self::Mul | Self::Div | Self::Mod => 20,
77 Self::Add | Self::Sub => 19,
78 Self::Shl | Self::Shr => 18,
79 Self::BitAnd => 17,
80 Self::BitXor => 16,
81 Self::BitOr => 15,
82 Self::Eq | Self::Ne | Self::Lt | Self::Gt | Self::Le | Self::Ge => 10,
83 Self::And | Self::Or => 9,
84 Self::RangeOpen | Self::RangeClose => 5,
85 _ => usize::MIN,
86 }
87 }
88}
89
90#[derive(Debug, Clone)]
91pub struct Expr {
92 pub kind: ExprKind,
93 pub span: Span,
94}
95
96#[derive(Debug, Clone, Default)]
97pub enum ExprKind {
98 #[default]
99 Null,
100 Value(Dynamic),
101 Const(usize),
102 Typed {
103 value: Box<Expr>,
104 ty: Type,
105 },
106 Unary {
107 op: UnaryOp,
108 value: Box<Expr>,
109 },
110 Binary {
111 left: Box<Expr>,
112 op: BinaryOp,
113 right: Box<Expr>,
114 },
115 Ident(SmolStr),
116 Var(u32),
117 Capture(u32),
118 Id(u32, Option<Box<Expr>>),
119 Generic {
120 obj: Box<Expr>,
121 params: Vec<Type>,
122 },
123 Assoc {
124 ty: Type,
125 name: SmolStr,
126 },
127 TypedMethod {
128 obj: Box<Expr>,
129 ty: Type,
130 name: SmolStr,
131 },
132 AssocId {
133 id: u32,
134 params: Vec<Type>,
135 },
136 Tuple(Vec<Expr>),
137 List(Vec<Expr>),
138 Repeat {
139 value: Box<Expr>,
140 len: Type,
141 },
142 Dict(Vec<(SmolStr, Expr)>),
143 Range {
144 start: Box<Expr>,
145 stop: Box<Expr>,
146 inclusive: bool,
147 },
148 Call {
149 obj: Box<Expr>,
150 params: Vec<Expr>,
151 },
152 Stmt(Box<Stmt>),
153 Closure {
154 args: Vec<(SmolStr, Type)>,
155 body: Box<Stmt>,
156 },
157}
158
159#[derive(Debug, thiserror::Error)]
160pub enum ExprErr {
161 #[error("{0} 不是标识符")]
162 NotIdent(SmolStr),
163 #[error("{0} 非原生类型")]
164 NotNative(SmolStr),
165 #[error("期望表达式")]
166 ExpectExpr,
167}
168
169impl Default for Expr {
170 fn default() -> Self {
171 Self::new(ExprKind::Null, Span::default())
172 }
173}
174
175impl From<Dynamic> for Expr {
176 fn from(value: Dynamic) -> Self {
177 Self::new(ExprKind::Value(value), Span::default())
178 }
179}
180
181impl Expr {
182 pub fn new(kind: ExprKind, span: Span) -> Self {
183 Self { kind, span }
184 }
185
186 pub fn with_span(mut self, span: Span) -> Self {
187 self.span = span;
188 self
189 }
190
191 pub fn is_range(&self) -> bool {
192 matches!(self.kind, ExprKind::Range { .. })
193 }
194
195 pub fn is_typed(&self) -> bool {
196 matches!(self.kind, ExprKind::Typed { .. })
197 }
198
199 pub fn get_type(&self) -> Type {
200 match &self.kind {
201 ExprKind::Typed { ty, .. } => ty.clone(),
202 ExprKind::Value(v) => v.get_type(),
203 ExprKind::Unary { value, .. } => value.get_type(),
204 ExprKind::Tuple(list) => Type::Tuple(list.iter().map(|l| l.get_type()).collect()),
205 ExprKind::List(list) => {
206 if list.is_empty() {
207 return Type::list_any();
208 }
209 let mut elem_ty = Type::Any;
210 for item in list {
211 let item_ty = item.get_type();
212 elem_ty = if elem_ty.is_any() { item_ty } else { elem_ty + item_ty };
213 }
214 Type::Array(std::rc::Rc::new(elem_ty), list.len() as u32)
215 }
216 ExprKind::Repeat { value, len } => {
217 if let Type::ConstInt(len) = len {
218 Type::Array(std::rc::Rc::new(value.get_type()), *len as u32)
219 } else {
220 Type::ArrayParam(std::rc::Rc::new(value.get_type()), std::rc::Rc::new(len.clone()))
221 }
222 }
223 ExprKind::Range { start, .. } => start.get_type(),
224 ExprKind::Stmt(stmt) => stmt.get_type().unwrap_or(Type::Any),
225 _ => Type::Any,
226 }
227 }
228
229 pub fn id(&self) -> Option<u32> {
230 if let ExprKind::Id(id, _) = &self.kind { Some(*id) } else { None }
231 }
232
233 pub fn var(&self) -> Option<u32> {
234 if let ExprKind::Var(idx) = &self.kind { Some(*idx) } else { None }
235 }
236
237 pub fn ident(&self) -> Result<&str> {
238 if let ExprKind::Ident(ident) = &self.kind { Ok(ident.as_str()) } else { Err(ExprErr::NotIdent(SmolStr::from(format!("{:?}", self))).into()) }
239 }
240
241 pub fn binary_op(&self) -> Option<BinaryOp> {
242 if let ExprKind::Binary { op, .. } = &self.kind { Some(op.clone()) } else { None }
243 }
244
245 pub fn is_idx(&self) -> bool {
246 matches!(&self.kind, ExprKind::Binary { op, .. } if *op == BinaryOp::Idx)
247 }
248
249 pub fn is_value(&self) -> bool {
250 match &self.kind {
251 ExprKind::Value(_) => true,
252 ExprKind::Typed { value, ty } => ty.is_native() && value.is_value(),
253 _ => false,
254 }
255 }
256
257 pub fn is_const(&self) -> bool {
258 matches!(self.kind, ExprKind::Const(_))
259 }
260
261 pub fn value(self) -> Result<Dynamic> {
262 match self.kind {
263 ExprKind::Value(v) => Ok(v),
264 ExprKind::Typed { value, ty } => {
265 if ty.is_native() {
266 Ok(ty.force(value.value()?)?)
267 } else {
268 Err(anyhow!("不是 Value"))
269 }
270 }
271 _ => Err(anyhow!("不是 Value")),
272 }
273 }
274
275 pub fn binary(self) -> Option<(Expr, BinaryOp, Expr)> {
276 match self.kind {
277 ExprKind::Binary { left, op, right } => Some((*left, op, *right)),
278 _ => None,
279 }
280 }
281
282 pub fn compact(&self) -> Option<Dynamic> {
283 match &self.kind {
284 ExprKind::Value(v) => Some(v.clone()),
285 ExprKind::Unary { op, value } => {
286 if value.is_value() {
287 let v = value.clone().value().unwrap();
288 match op {
289 UnaryOp::Neg => Some(-v),
290 UnaryOp::Not => Some(!v),
291 _ => None,
292 }
293 } else {
294 None
295 }
296 }
297 ExprKind::Binary { left, op, right } => {
298 if left.is_value() && right.is_value() {
299 let left = left.clone().value().unwrap();
300 let right = right.clone().value().unwrap();
301 let r = match op {
302 BinaryOp::Add | BinaryOp::AddAssign => left + right,
303 BinaryOp::Sub | BinaryOp::SubAssign => left - right,
304 BinaryOp::Mul | BinaryOp::MulAssign => left * right,
305 BinaryOp::Div | BinaryOp::DivAssign => left / right,
306 BinaryOp::Mod | BinaryOp::ModAssign => left % right,
307 BinaryOp::And => Dynamic::Bool(left.is_true() && right.is_true()),
308 BinaryOp::Or => Dynamic::Bool(left.is_true() || right.is_true()),
309 BinaryOp::Eq => Dynamic::Bool(left == right),
310 BinaryOp::Ne => Dynamic::Bool(left != right),
311 BinaryOp::Le => Dynamic::Bool(left <= right),
312 BinaryOp::Lt => Dynamic::Bool(left < right),
313 BinaryOp::Ge => Dynamic::Bool(left >= right),
314 BinaryOp::Gt => Dynamic::Bool(left > right),
315 BinaryOp::Shl | BinaryOp::ShlAssign => left << right,
316 BinaryOp::Shr | BinaryOp::ShrAssign => left >> right,
317 BinaryOp::Assign => right,
318 BinaryOp::BitAnd | BinaryOp::BitAndAssign => left & right,
319 BinaryOp::BitXor | BinaryOp::BitXorAssign => left ^ right,
320 BinaryOp::BitOr | BinaryOp::BitOrAssign => left | right,
321 BinaryOp::Idx => {
322 if let Some(idx) = right.as_int() {
323 return left.get_idx(idx as usize);
324 } else if let Ok(key) = SmolStr::try_from(right) {
325 return left.get_dynamic(&key);
326 } else {
327 return None;
328 }
329 }
330 _ => Dynamic::Null,
331 };
332 Some(r)
333 } else {
334 None
335 }
336 }
337 _ => None,
338 }
339 }
340}
341
342impl Parser {
343 fn is_dict_item_boundary(ch: u8) -> bool {
344 matches!(ch, b',' | b'}')
345 }
346
347 fn is_shorthand_field_name(name: &str) -> bool {
348 name.as_bytes().first().is_some_and(|ch| ch.is_ascii_alphabetic() || *ch == b'_')
349 }
350
351 pub(crate) fn looks_like_dict(&mut self) -> bool {
352 let save_pos = self.pos;
353 let result = (|| -> Result<bool> {
354 self.whitespace()?;
355 if self.take(b'{').is_err() {
356 return Ok(false);
357 }
358 self.whitespace()?;
359 if self.take(b'}').is_ok() {
360 return Ok(true);
361 }
362 if self.ident().is_err() && self.string().is_err() {
363 return Ok(false);
364 }
365 self.whitespace()?;
366 Ok(matches!(self.get(), Ok(b':' | b',' | b'}')))
367 })()
368 .unwrap_or(false);
369 self.pos = save_pos;
370 result
371 }
372
373 pub(crate) fn looks_like_empty_dict(&mut self) -> bool {
374 let save_pos = self.pos;
375 let result = (|| -> Result<bool> {
376 self.whitespace()?;
377 self.take(b'{')?;
378 self.whitespace()?;
379 Ok(self.take(b'}').is_ok())
380 })()
381 .unwrap_or(false);
382 self.pos = save_pos;
383 result
384 }
385
386 fn postfix_expr(&mut self, start: usize, mut expr: Expr) -> Result<Expr> {
387 while !self.is_eof() && [b'.', b'[', b'(', b':'].contains(&self.get()?) {
388 if self.ahead()? == b'.' && self.get()? == b'.' {
389 break;
390 }
391 if self.just("::<").is_ok() {
392 let params = crate::parse_list!(self, Vec::new(), b'>', b',', self.get_type_param()?);
393 self.whitespace()?;
394 if self.just("::").is_ok() {
395 if params.len() != 1 {
396 return Err(anyhow!("类型提示只能包含一个类型参数"));
397 }
398 let name = self.ident()?;
399 expr = Expr::new(ExprKind::TypedMethod { obj: Box::new(expr), ty: params[0].clone(), name }, Span::new(start, self.current_pos()));
400 } else {
401 expr = Expr::new(ExprKind::Generic { obj: Box::new(expr), params }, Span::new(start, self.current_pos()));
402 }
403 } else if self.take(b'.').is_ok() {
404 let key_start = self.current_pos();
405 let key = self.ident()?;
406 let right = Expr::new(ExprKind::Value(Dynamic::String(key)), self.span_from(key_start));
407 let span = expr.span.merge(right.span);
408 expr = Expr::new(ExprKind::Binary { left: Box::new(expr), op: BinaryOp::Idx, right: Box::new(right) }, span);
409 } else if self.take(b'[').is_ok() {
410 let key = self.expr(None, None)?.0;
411 self.until(b']')?;
412 let span = Span::new(start, self.current_pos());
413 expr = Expr::new(ExprKind::Binary { left: Box::new(expr), op: BinaryOp::Idx, right: Box::new(key) }, span);
414 } else if self.take(b'(').is_ok() {
415 let params = crate::parse_list!(self, Vec::new(), b')', b',', self.expr(None, None)?.0);
416 expr = Expr::new(ExprKind::Call { obj: Box::new(expr), params }, Span::new(start, self.current_pos()));
417 } else {
418 break;
419 }
420 }
421 Ok(expr.with_span(Span::new(start, self.current_pos())))
422 }
423
424 fn binary_op(&mut self) -> Option<BinaryOp> {
425 if self.just("<<=").is_ok() {
426 Some(BinaryOp::ShlAssign)
427 } else if self.just(">>=").is_ok() {
428 Some(BinaryOp::ShrAssign)
429 } else if self.just("<<").is_ok() {
430 Some(BinaryOp::Shl)
431 } else if self.just(">>").is_ok() {
432 Some(BinaryOp::Shr)
433 } else if self.just(">=").is_ok() {
434 Some(BinaryOp::Ge)
435 } else if self.just("==").is_ok() {
436 Some(BinaryOp::Eq)
437 } else if self.just("!=").is_ok() {
438 Some(BinaryOp::Ne)
439 } else if self.just("<=").is_ok() {
440 Some(BinaryOp::Le)
441 } else if self.just("&&").is_ok() {
442 Some(BinaryOp::And)
443 } else if self.just("||").is_ok() {
444 Some(BinaryOp::Or)
445 } else if self.just("+=").is_ok() {
446 Some(BinaryOp::AddAssign)
447 } else if self.just("-=").is_ok() {
448 Some(BinaryOp::SubAssign)
449 } else if self.just("*=").is_ok() {
450 Some(BinaryOp::MulAssign)
451 } else if self.just("/=").is_ok() {
452 Some(BinaryOp::DivAssign)
453 } else if self.just("%=").is_ok() {
454 Some(BinaryOp::ModAssign)
455 } else if self.just("&=").is_ok() {
456 Some(BinaryOp::BitAndAssign)
457 } else if self.just("|=").is_ok() {
458 Some(BinaryOp::BitOrAssign)
459 } else if self.just("^=").is_ok() {
460 Some(BinaryOp::BitXorAssign)
461 } else if self.just("..=").is_ok() {
462 Some(BinaryOp::RangeClose)
463 } else if self.just("..").is_ok() {
464 Some(BinaryOp::RangeOpen)
465 } else {
466 match self.get() {
467 Ok(b'+') => {
468 self.pos += 1;
469 Some(BinaryOp::Add)
470 }
471 Ok(b'-') => {
472 self.pos += 1;
473 Some(BinaryOp::Sub)
474 }
475 Ok(b'*') => {
476 self.pos += 1;
477 Some(BinaryOp::Mul)
478 }
479 Ok(b'/') => {
480 self.pos += 1;
481 Some(BinaryOp::Div)
482 }
483 Ok(b'%') => {
484 self.pos += 1;
485 Some(BinaryOp::Mod)
486 }
487 Ok(b'<') => {
488 self.pos += 1;
489 Some(BinaryOp::Lt)
490 }
491 Ok(b'>') => {
492 self.pos += 1;
493 Some(BinaryOp::Gt)
494 }
495 Ok(b'=') => {
496 self.pos += 1;
497 Some(BinaryOp::Assign)
498 }
499 Ok(b'&') => {
500 self.pos += 1;
501 Some(BinaryOp::BitAnd)
502 }
503 Ok(b'|') => {
504 self.pos += 1;
505 Some(BinaryOp::BitOr)
506 }
507 Ok(b'^') => {
508 self.pos += 1;
509 Some(BinaryOp::BitXor)
510 }
511 _ => None,
512 }
513 }
514 }
515
516 pub fn kv(&mut self) -> Result<(SmolStr, Expr)> {
517 let start = self.current_pos();
518 if let Ok(key) = self.ident() {
519 self.whitespace()?;
520 if self.take(b':').is_ok() {
521 let value = self.expr(None, None)?.0;
522 Ok((SmolStr::from(key), value))
523 } else if Self::is_shorthand_field_name(&key) && self.get().map(Self::is_dict_item_boundary).unwrap_or(false) {
524 let span = Span::new(start, start + key.len());
525 Ok((key.clone(), Expr::new(ExprKind::Ident(key), span)))
526 } else {
527 Err(anyhow!("expect ':' after field name"))
528 }
529 } else if let Ok(key) = self.string() {
530 self.until(b':')?;
531 let value = self.expr(None, None)?.0;
532 Ok((SmolStr::from(key), value))
533 } else {
534 Err(anyhow!("expect string as key"))
535 }
536 }
537
538 pub fn base_expr(&mut self, allow_struct_literal: bool) -> Result<Expr> {
539 let start = self.current_pos();
540 if let Ok(s) = self.text() {
541 let expr = Expr::new(ExprKind::Value(Dynamic::String(s)), self.span_from(start));
542 self.postfix_expr(start, expr)
543 } else if let Ok(n) = self.number() {
544 let expr = if let Ok(ty) = self.get_type() {
545 if ty.is_native() {
546 Expr::new(ExprKind::Typed { value: Box::new(Expr::new(ExprKind::Value(n), self.span_from(start))), ty }, self.span_from(start))
547 } else {
548 return Err(ExprErr::NotNative(SmolStr::from(format!("{:?}", ty))).into());
549 }
550 } else {
551 Expr::new(ExprKind::Value(n), self.span_from(start))
552 };
553 self.postfix_expr(start, expr)
554 } else if self.keyword("true").is_ok() {
555 let expr = Expr::new(ExprKind::Value(Dynamic::Bool(true)), self.span_from(start));
556 self.postfix_expr(start, expr)
557 } else if self.keyword("false").is_ok() {
558 let expr = Expr::new(ExprKind::Value(Dynamic::Bool(false)), self.span_from(start));
559 self.postfix_expr(start, expr)
560 } else if self.keyword("null").is_ok() {
561 let expr = Expr::new(ExprKind::Value(Dynamic::Null), self.span_from(start));
562 self.postfix_expr(start, expr)
563 } else if let Ok(ident) = self.ident() {
564 self.whitespace()?;
565 let save_pos = self.pos;
566 if self.take(b'<').is_ok() {
567 let typed_literal = (|| -> Result<Expr> {
568 let type_params = crate::parse_list!(self, Vec::new(), b'>', b',', self.get_type_param()?);
569 self.whitespace()?;
570 if self.just("::").is_ok() {
571 let name = self.ident()?;
572 let expr = Expr::new(ExprKind::Assoc { ty: Type::Ident { name: ident.clone(), params: type_params }, name }, self.span_from(start));
573 return self.postfix_expr(start, expr);
574 }
575 if allow_struct_literal
576 && self.looks_like_dict()
577 && let Ok(b'{') = self.get()
578 && let Ok(dict) = try_parse!(self, self.dict())
579 {
580 return Ok(Expr::new(ExprKind::Typed { value: Box::new(dict), ty: Type::Ident { name: ident.clone(), params: type_params } }, self.span_from(start)));
581 }
582 Err(ExprErr::ExpectExpr.into())
583 })();
584 if let Ok(expr) = typed_literal {
585 return Ok(expr);
586 }
587 self.pos = save_pos;
588 }
589 if allow_struct_literal
590 && self.looks_like_dict()
591 && let Ok(b'{') = self.get()
592 && let Ok(dict) = try_parse!(self, self.dict())
593 {
594 return Ok(Expr::new(ExprKind::Typed { value: Box::new(dict), ty: Type::Ident { name: ident, params: Vec::new() } }, self.span_from(start)));
595 }
596 self.postfix_expr(start, Expr::new(ExprKind::Ident(ident), self.span_from(start)))
597 } else {
598 Err(ExprErr::ExpectExpr.into())
599 }
600 }
601
602 pub(crate) fn dict(&mut self) -> Result<Expr> {
603 let start = self.current_pos();
604 self.pos += 1;
605 Ok(Expr::new(ExprKind::Dict(crate::parse_list!(self, Vec::new(), b'}', b',', self.kv()?)), self.span_from(start)))
606 }
607
608 fn static_dynamic_literal_expr(&mut self) -> Result<Expr> {
609 let start = self.current_pos();
610 let value = self.static_dynamic_value()?;
611 Ok(Expr::new(ExprKind::Value(value), self.span_from(start)))
612 }
613
614 fn static_dynamic_value(&mut self) -> Result<Dynamic> {
615 self.whitespace()?;
616 if self.get()? == b'[' {
617 return self.static_dynamic_list();
618 }
619 if self.get()? == b'{' {
620 return self.static_dynamic_map();
621 }
622 if self.take(b'-').is_ok() {
623 return Ok(-self.number()?);
624 }
625 if let Ok(text) = self.text() {
626 return Ok(Dynamic::String(text));
627 }
628 if let Ok(number) = self.number() {
629 return Ok(number);
630 }
631 if self.keyword("true").is_ok() {
632 return Ok(Dynamic::Bool(true));
633 }
634 if self.keyword("false").is_ok() {
635 return Ok(Dynamic::Bool(false));
636 }
637 if self.keyword("null").is_ok() {
638 return Ok(Dynamic::Null);
639 }
640 Err(ExprErr::ExpectExpr.into())
641 }
642
643 fn static_dynamic_list(&mut self) -> Result<Dynamic> {
644 self.take(b'[')?;
645 let mut values = Vec::new();
646 loop {
647 self.whitespace()?;
648 if self.take(b']').is_ok() {
649 break;
650 }
651 values.push(self.static_dynamic_value()?);
652 self.whitespace()?;
653 if self.take(b',').is_ok() {
654 continue;
655 }
656 self.until(b']')?;
657 break;
658 }
659 Ok(Dynamic::list(values))
660 }
661
662 fn static_dynamic_map(&mut self) -> Result<Dynamic> {
663 self.take(b'{')?;
664 let mut values = std::collections::BTreeMap::new();
665 loop {
666 self.whitespace()?;
667 if self.take(b'}').is_ok() {
668 break;
669 }
670 let key = if let Ok(key) = self.ident() { key } else { self.string()? };
671 self.until(b':')?;
672 let value = self.static_dynamic_value()?;
673 values.insert(key, value);
674 self.whitespace()?;
675 if self.take(b',').is_ok() {
676 continue;
677 }
678 self.until(b'}')?;
679 break;
680 }
681 Ok(Dynamic::map(values))
682 }
683
684 pub fn get_expr(&mut self) -> Result<Expr> {
685 self.expr(None, None).map(|(e, _)| e)
686 }
687
688 pub fn get_expr_without_struct_literal(&mut self) -> Result<Expr> {
689 self.expr_with_min_weight(None, None, 0, false).map(|(e, _)| e)
690 }
691
692 pub fn expr(&mut self, left: Option<(Expr, bool)>, left_op: Option<BinaryOp>) -> Result<(Expr, bool)> {
693 self.expr_with_min_weight(left, left_op, 0, true)
694 }
695
696 fn expr_with_min_weight(&mut self, left: Option<(Expr, bool)>, left_op: Option<BinaryOp>, min_weight: usize, allow_struct_literal: bool) -> Result<(Expr, bool)> {
697 self.whitespace()?;
698 if self.is_eof() {
699 return left.ok_or(ParserErr::EndofInput.into());
700 }
701 let start = self.current_pos();
702 let ch = self.get()?;
703 let mut expr = if ch == b'(' {
704 let start = self.current_pos();
705 self.pos += 1;
706 self.whitespace()?;
707 if self.take(b')').is_ok() {
708 let expr = Expr::new(ExprKind::Tuple(Vec::new()), Span::new(start, self.current_pos()));
709 return Ok((self.postfix_expr(start, expr)?, true));
710 }
711 let (e, _closed) = self.expr_with_min_weight(None, None, 0, true)?;
712 self.whitespace()?;
713 if self.get()? == b',' {
714 self.pos += 1;
715 let list = crate::parse_list!(self, vec![e], b')', b',', self.expr_with_min_weight(None, None, 0, true)?.0);
716 let expr = Expr::new(ExprKind::Tuple(list), Span::new(start, self.current_pos()));
717 Ok((self.postfix_expr(start, expr)?, true))
718 } else {
719 self.until(b')')?;
720 let expr = e.with_span(Span::new(start, self.current_pos()));
721 Ok((self.postfix_expr(start, expr)?, true))
722 }
723 } else if ch == b'!' && self.ahead().map(|a| a != b'=').unwrap_or(true) {
724 let start = self.current_pos();
725 self.pos += 1;
726 let value = self.expr_with_min_weight(None, None, BinaryOp::Mul.weight() + 1, allow_struct_literal)?.0;
727 Ok((Expr::new(ExprKind::Unary { op: UnaryOp::Not, value: Box::new(value) }, Span::new(start, self.current_pos())), false))
728 } else if ch == b'-' && self.ahead().map(|a| a != b'=').unwrap_or(true) && (left.is_none() || (left.is_some() && left_op.is_some())) {
729 let start = self.current_pos();
730 self.pos += 1;
731 let value = self.expr_with_min_weight(None, None, BinaryOp::Mul.weight() + 1, allow_struct_literal)?.0;
732 Ok((Expr::new(ExprKind::Unary { op: UnaryOp::Neg, value: Box::new(value) }, Span::new(start, self.current_pos())), false))
733 } else if ch == b'[' {
734 if let Ok(expr) = try_parse!(self, self.static_dynamic_literal_expr()) {
735 Ok((self.postfix_expr(start, expr)?, false))
736 } else {
737 let start = self.current_pos();
738 self.pos += 1;
739 self.whitespace()?;
740 if self.take(b']').is_ok() {
741 let expr = Expr::new(ExprKind::List(Vec::new()), Span::new(start, self.current_pos()));
742 Ok((self.postfix_expr(start, expr)?, false))
743 } else {
744 let first = self.expr_with_min_weight(None, None, 0, true)?.0;
745 self.whitespace()?;
746 if self.take(b';').is_ok() {
747 let len = self.get_type_param()?;
748 self.until(b']')?;
749 let expr = Expr::new(ExprKind::Repeat { value: Box::new(first), len }, Span::new(start, self.current_pos()));
750 Ok((self.postfix_expr(start, expr)?, false))
751 } else {
752 let mut items = vec![first];
753 let mut closed = false;
754 while self.take(b',').is_ok() {
755 self.whitespace()?;
756 if self.take(b']').is_ok() {
757 closed = true;
758 break;
759 }
760 items.push(self.expr_with_min_weight(None, None, 0, true)?.0);
761 self.whitespace()?;
762 }
763 if !closed {
764 self.until(b']')?;
765 }
766 let expr = Expr::new(ExprKind::List(items), Span::new(start, self.current_pos()));
767 Ok((self.postfix_expr(start, expr)?, false))
768 }
769 }
770 }
771 } else if ch == b'{'
772 && (left.is_none() || left_op.is_some())
773 && let Ok(expr) = try_parse!(self, self.static_dynamic_literal_expr())
774 {
775 Ok((self.postfix_expr(start, expr)?, false))
776 } else if ch == b'{'
777 && (left.is_none() || left_op.is_some())
778 && let Ok(dict) = try_parse!(self, self.dict())
779 {
780 Ok((self.postfix_expr(start, dict)?, false))
781 } else if (left.is_none() || left_op.is_some()) && self.keyword("if").is_ok() {
782 let stmt = self.if_block()?;
783 Ok((Expr::new(ExprKind::Stmt(Box::new(stmt)), Span::new(start, self.current_pos())), true))
784 } else if ch == b'|' && left.is_none() {
785 let start = self.current_pos();
786 self.pos += 1;
787 let args = crate::parse_list!(self, Vec::new(), b'|', b',', self.ident_typed()?);
788 let body = Box::new(self.block()?);
789 let expr = Expr::new(ExprKind::Closure { args, body }, Span::new(start, self.current_pos()));
790 Ok((self.postfix_expr(start, expr)?, true))
791 } else if let Some(this_op) = self.binary_op() {
792 let (left, close) = left.ok_or(anyhow!("{:?} need left value", this_op))?;
793 if this_op == BinaryOp::RangeOpen {
794 self.whitespace()?;
795 if self.get()? == b']' {
796 let span = Span::new(left.span.start, self.current_pos());
797 let stop = Expr::new(ExprKind::Value(Dynamic::Null), Span::empty(self.current_pos()));
798 return Ok((Expr::new(ExprKind::Range { start: Box::new(left), stop: Box::new(stop), inclusive: false }, span), false));
799 }
800 }
801 if this_op.weight() < min_weight {
802 self.pos = start;
803 return Ok((left, close));
804 }
805 if left_op.is_some() {
806 return Err(anyhow!("unexpected binary op {:?}", this_op));
807 }
808 return if !close && left.binary_op().map(|op| op.weight() < this_op.weight()).unwrap_or(false) {
809 let (binary_left, op, right) = left.binary().unwrap();
810 let this_weight = this_op.weight();
811 let new_right = self.expr_with_min_weight(Some((right, false)), Some(this_op), this_weight, allow_struct_literal)?.0;
812 let span = binary_left.span.merge(new_right.span);
813 let expr = Expr::new(ExprKind::Binary { left: Box::new(binary_left), op, right: Box::new(new_right) }, span);
814 self.expr_with_min_weight(Some((expr, false)), None, min_weight, allow_struct_literal)
815 } else {
816 self.expr_with_min_weight(Some((left, false)), Some(this_op), min_weight, allow_struct_literal)
817 };
818 } else if self.keyword("as").is_ok() && left.is_some() {
819 let value = left.unwrap().0;
820 let start = value.span.start;
821 let ty = self.get_type()?;
822 return Ok((Expr::new(ExprKind::Typed { value: Box::new(value), ty }, Span::new(start, self.current_pos())), false));
823 } else {
824 self.base_expr(allow_struct_literal).map(|e| (e, false))
825 };
826
827 if left.is_some() {
828 if let Some(op) = left_op {
829 let left = left.unwrap().0;
830 let right = expr?.0;
831 let span = left.span.merge(right.span);
832 expr = Ok((
833 match op {
834 BinaryOp::RangeOpen => Expr::new(ExprKind::Range { start: Box::new(left), stop: Box::new(right), inclusive: false }, span),
835 BinaryOp::RangeClose => Expr::new(ExprKind::Range { start: Box::new(left), stop: Box::new(right), inclusive: true }, span),
836 _ => Expr::new(ExprKind::Binary { left: Box::new(left), op, right: Box::new(right) }, span),
837 },
838 false,
839 ));
840 } else if expr.is_ok() {
841 return Err(anyhow!("unexpected {:?}", expr));
842 } else {
843 return Ok((left.unwrap().0, false));
844 }
845 }
846 let result = self.expr_with_min_weight(Some(expr?), None, min_weight, allow_struct_literal)?;
847 Ok(result)
848 }
849}