1use alloc::collections::BTreeMap;
18use alloc::string::String;
19use alloc::vec::Vec;
20use core::fmt;
21
22use hir_lang::{CaptureMode, DivZero, FloatToInt, Op, OpKind, Overflow, Prim, Shift, Span};
23
24use crate::template::{
25 ArgsHole, ExprHole, HoleKind, LabelHole, LabelRef, PatHole, StmtsHole, TArg, TBinder, TExpr,
26 TLabel, TLit, TPat, TStmt, TTy, Template, TemplateBuilder, TemplateError, TemplateId, TyHole,
27};
28
29pub const MAX_TEMPLATE_TEXT: usize = 1 << 20;
44
45pub const MAX_TEMPLATE_DEPTH: u32 = 32;
64
65#[derive(Clone, Copy, Debug, PartialEq, Eq)]
79#[non_exhaustive]
80pub enum SyntaxError {
81 TooLong,
84 TooDeep,
87 UnexpectedChar,
90 Unterminated,
92 BadEscape,
94 BadNumber,
96 Expected(&'static str),
98 UnknownName,
101 BinderId,
104 UnknownOp,
107 BadPolicy,
110 Arity {
112 expected: usize,
114 found: usize,
116 },
117 HoleKind {
120 first: HoleKind,
122 here: HoleKind,
124 },
125 HoleSuffix,
127 HoleDefault,
130 SpliceHere,
133 BoundTwice,
135 UnknownLabel,
137 UnknownTemplate,
139 ApplyArgs,
142 Unsupported(&'static str),
144}
145
146impl fmt::Display for SyntaxError {
147 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
148 match self {
149 Self::TooLong => write!(
150 f,
151 "the template text is longer than {MAX_TEMPLATE_TEXT} bytes"
152 ),
153 Self::TooDeep => write!(
154 f,
155 "the template nests deeper than {MAX_TEMPLATE_DEPTH} levels"
156 ),
157 Self::UnexpectedChar => f.write_str("unexpected character"),
158 Self::Unterminated => f.write_str("unterminated literal or hole"),
159 Self::BadEscape => f.write_str("unknown escape sequence"),
160 Self::BadNumber => f.write_str("malformed or out-of-range number"),
161 Self::Expected(what) => write!(f, "expected {what}"),
162 Self::UnknownName => f.write_str(
163 "unknown name (free names are written `global:name`, host symbols `extern:name`)",
164 ),
165 Self::BinderId => {
166 f.write_str("template binders are written without an id (`x`, not `x%0`)")
167 }
168 Self::UnknownOp => f.write_str("unknown operation, or a conversion without a target"),
169 Self::BadPolicy => f.write_str("a policy the operation does not take"),
170 Self::Arity { expected, found } => {
171 write!(f, "the operation takes {expected} operands, {found} given")
172 }
173 Self::HoleKind { first, here } => {
174 write!(f, "the hole is used as {first:?} and as {here:?}")
175 }
176 Self::HoleSuffix => f.write_str("the hole's uses disagree on `?` or its default"),
177 Self::HoleDefault => {
178 f.write_str("only expression holes take a default, and it must be a literal")
179 }
180 Self::SpliceHere => f.write_str(
181 "an argument splice must be a call argument, a tuple or array element, or a statement",
182 ),
183 Self::BoundTwice => f.write_str("the name is bound twice in one pattern"),
184 Self::UnknownLabel => f.write_str("no enclosing loop or block has this label"),
185 Self::UnknownTemplate => f.write_str("no template of this name is registered before"),
186 Self::ApplyArgs => f.write_str("the arguments do not fit the applied template's holes"),
187 Self::Unsupported(what) => write!(f, "{what} are not supported in templates"),
188 }
189 }
190}
191
192#[derive(Clone, Copy, Debug, PartialEq)]
196enum Suffix {
197 None,
198 Optional,
199 Default(TLit),
200}
201
202#[derive(Clone, Copy, Debug, PartialEq, Eq)]
203enum Free {
204 Extern,
205 Global,
206 Apply,
207}
208
209#[derive(Clone, Copy, Debug, PartialEq)]
210enum T {
211 Ident,
212 Int(i64),
213 Float(f64),
214 Str(u32),
216 Char(char),
217 Label,
219 Hole {
222 splice: bool,
223 name: (u32, u32),
224 suffix: Suffix,
225 },
226 Free(Free),
229 P(u8),
231 Arrow,
233 Eof,
234}
235
236#[derive(Clone, Copy, Debug)]
237struct Tok {
238 t: T,
239 s: u32,
240 e: u32,
241}
242
243type R<T> = Result<T, TemplateError>;
244
245fn err<T>(s: u32, e: u32, error: SyntaxError) -> R<T> {
246 Err(TemplateError::Syntax {
247 at: Span::new(s, e.max(s)),
248 error,
249 })
250}
251
252const fn ident_start(b: u8) -> bool {
253 b.is_ascii_alphabetic() || b == b'_'
254}
255
256const fn ident_char(b: u8) -> bool {
257 b.is_ascii_alphanumeric() || b == b'_'
258}
259
260struct Lexer<'a> {
262 text: &'a str,
263 bytes: &'a [u8],
264 i: usize,
265 toks: Vec<Tok>,
266 strs: Vec<String>,
267}
268
269impl<'a> Lexer<'a> {
270 fn run(text: &'a str) -> R<(Vec<Tok>, Vec<String>)> {
271 let mut lx = Lexer {
272 text,
273 bytes: text.as_bytes(),
274 i: 0,
275 toks: Vec::new(),
276 strs: Vec::new(),
277 };
278 while lx.i < lx.bytes.len() {
279 lx.next()?;
280 }
281 let end = lx.pos(lx.bytes.len());
282 lx.toks.push(Tok {
283 t: T::Eof,
284 s: end,
285 e: end,
286 });
287 Ok((lx.toks, lx.strs))
288 }
289
290 fn pos(&self, i: usize) -> u32 {
292 u32::try_from(i).unwrap_or(u32::MAX)
293 }
294
295 fn at(&self, i: usize) -> u8 {
296 self.bytes.get(i).copied().unwrap_or(0)
297 }
298
299 fn push(&mut self, t: T, s: usize, e: usize) {
300 let (s, e) = (self.pos(s), self.pos(e));
301 self.toks.push(Tok { t, s, e });
302 }
303
304 fn next(&mut self) -> R<()> {
305 let start = self.i;
306 let b = self.at(start);
307 match b {
308 b' ' | b'\t' | b'\n' | b'\r' => {
309 self.i += 1;
310 Ok(())
311 }
312 b'$' if self.at(start + 1) == b'{' => self.hole(),
313 b'"' => self.string(),
314 b'\'' => self.quote(),
315 b'0'..=b'9' => self.number(start, false),
316 b'-' if self.at(start + 1).is_ascii_digit() => self.number(start, true),
317 b'=' if self.at(start + 1) == b'>' => {
318 self.i += 2;
319 self.push(T::Arrow, start, start + 2);
320 Ok(())
321 }
322 b'{' | b'}' | b'(' | b')' | b'[' | b']' | b',' | b';' | b'=' | b':' | b'<' | b'>'
323 | b'|' | b'&' | b'.' | b'-' => {
324 self.i += 1;
325 self.push(T::P(b), start, start + 1);
326 Ok(())
327 }
328 _ if ident_start(b) => self.word(),
329 _ => {
330 let len = self.text.get(start..).and_then(|r| r.chars().next());
331 let end = start + len.map_or(1, char::len_utf8);
332 err(self.pos(start), self.pos(end), SyntaxError::UnexpectedChar)
333 }
334 }
335 }
336
337 fn word(&mut self) -> R<()> {
338 let start = self.i;
339 while ident_char(self.at(self.i)) {
340 self.i += 1;
341 }
342 let word = self.text.get(start..self.i).unwrap_or("");
343 if self.at(self.i) == b'%' {
344 return err(self.pos(start), self.pos(self.i + 1), SyntaxError::BinderId);
345 }
346 let free = match word {
347 "extern" => Some(Free::Extern),
348 "global" => Some(Free::Global),
349 "apply" => Some(Free::Apply),
350 _ => None,
351 };
352 if let (Some(kind), b':') = (free, self.at(self.i)) {
353 self.i += 1;
355 if !ident_start(self.at(self.i)) {
356 return err(
357 self.pos(start),
358 self.pos(self.i),
359 SyntaxError::Expected("a name after the prefix"),
360 );
361 }
362 while ident_char(self.at(self.i)) || matches!(self.at(self.i), b'.' | b':') {
363 self.i += 1;
364 }
365 self.push(T::Free(kind), start, self.i);
366 return Ok(());
367 }
368 self.push(T::Ident, start, self.i);
369 Ok(())
370 }
371
372 fn hole(&mut self) -> R<()> {
373 let start = self.i;
374 self.i += 2;
375 let splice = self.bytes.get(self.i..self.i + 3) == Some(b"...");
376 if splice {
377 self.i += 3;
378 }
379 let name_start = self.i;
380 while matches!(self.at(self.i), b'a'..=b'z' | b'_') {
381 self.i += 1;
382 }
383 if self.i == name_start {
384 return err(
385 self.pos(start),
386 self.pos(self.i),
387 SyntaxError::Expected("a hole name (lowercase letters and `_`)"),
388 );
389 }
390 let name = (self.pos(name_start), self.pos(self.i));
391 let mut suffix = Suffix::None;
392 if self.at(self.i) == b'?' {
393 self.i += 1;
394 suffix = Suffix::Optional;
395 if self.at(self.i) == b'=' {
396 self.i += 1;
397 let lit_start = self.i;
398 while self.i < self.bytes.len() && self.at(self.i) != b'}' {
399 self.i += 1;
400 }
401 let lit = self.text.get(lit_start..self.i).unwrap_or("");
402 suffix = Suffix::Default(self.default_lit(lit, lit_start)?);
403 }
404 }
405 if self.at(self.i) != b'}' {
406 let at = if self.i >= self.bytes.len() {
407 SyntaxError::Unterminated
408 } else {
409 SyntaxError::Expected("`}` closing the hole")
410 };
411 return err(self.pos(start), self.pos(self.i), at);
412 }
413 self.i += 1;
414 self.push(
415 T::Hole {
416 splice,
417 name,
418 suffix,
419 },
420 start,
421 self.i,
422 );
423 Ok(())
424 }
425
426 fn default_lit(&self, lit: &str, at: usize) -> R<TLit> {
428 let (s, e) = (self.pos(at), self.pos(at + lit.len()));
429 let mut inner = Lexer {
430 text: lit,
431 bytes: lit.as_bytes(),
432 i: 0,
433 toks: Vec::new(),
434 strs: Vec::new(),
435 };
436 while inner.i < inner.bytes.len() {
437 if inner.next().is_err() {
438 return err(s, e, SyntaxError::HoleDefault);
439 }
440 }
441 let word = |t: &Tok| lit.get(t.s as usize..t.e as usize).unwrap_or("");
442 match inner.toks.as_slice() {
443 [t] => match t.t {
444 T::Int(v) => Ok(TLit::Int(v)),
445 T::Float(v) => Ok(TLit::Float(v)),
446 T::Char(c) => Ok(TLit::Char(c)),
447 T::Ident if word(t) == "true" => Ok(TLit::Bool(true)),
448 T::Ident if word(t) == "false" => Ok(TLit::Bool(false)),
449 T::Ident if word(t) == "null" => Ok(TLit::Null),
450 _ => err(s, e, SyntaxError::HoleDefault),
451 },
452 _ => err(s, e, SyntaxError::HoleDefault),
453 }
454 }
455
456 fn number(&mut self, start: usize, negative: bool) -> R<()> {
457 if negative {
458 self.i += 1;
459 }
460 let digits = self.i;
461 let radix = match (self.at(digits), self.at(digits + 1)) {
462 (b'0', b'x' | b'X') => 16,
463 (b'0', b'o' | b'O') => 8,
464 (b'0', b'b' | b'B') => 2,
465 _ => 10,
466 };
467 let bad = |lx: &Self| err(lx.pos(start), lx.pos(lx.i), SyntaxError::BadNumber);
468 if radix != 10 {
469 self.i += 2;
470 let from = self.i;
471 while self.at(self.i).is_ascii_alphanumeric() || self.at(self.i) == b'_' {
472 self.i += 1;
473 }
474 let mut v: u64 = 0;
475 let mut any = false;
476 for &c in self.bytes.get(from..self.i).unwrap_or(&[]) {
477 if c == b'_' {
478 continue;
479 }
480 let d = match char::from(c).to_digit(radix) {
481 Some(d) => u64::from(d),
482 None => return bad(self),
483 };
484 v = match v
485 .checked_mul(u64::from(radix))
486 .and_then(|v| v.checked_add(d))
487 {
488 Some(v) => v,
489 None => return bad(self),
490 };
491 any = true;
492 }
493 if !any {
494 return bad(self);
495 }
496 return self.int(v, negative, start);
497 }
498 while self.at(self.i).is_ascii_digit() || self.at(self.i) == b'_' {
499 self.i += 1;
500 }
501 let mut float = false;
502 if self.at(self.i) == b'.' && self.at(self.i + 1).is_ascii_digit() {
503 float = true;
504 self.i += 1;
505 while self.at(self.i).is_ascii_digit() || self.at(self.i) == b'_' {
506 self.i += 1;
507 }
508 }
509 if matches!(self.at(self.i), b'e' | b'E') {
510 let mut j = self.i + 1;
511 if matches!(self.at(j), b'+' | b'-') {
512 j += 1;
513 }
514 if self.at(j).is_ascii_digit() {
515 float = true;
516 self.i = j;
517 while self.at(self.i).is_ascii_digit() {
518 self.i += 1;
519 }
520 }
521 }
522 if ident_char(self.at(self.i)) {
523 while ident_char(self.at(self.i)) {
525 self.i += 1;
526 }
527 return bad(self);
528 }
529 let raw = self.text.get(start..self.i).unwrap_or("");
530 let mut clean = String::with_capacity(raw.len());
531 clean.extend(raw.chars().filter(|&c| c != '_'));
532 if float {
533 match clean.parse::<f64>() {
534 Ok(v) if v.is_finite() => {
535 self.push(T::Float(v), start, self.i);
536 Ok(())
537 }
538 _ => bad(self),
539 }
540 } else {
541 let magnitude = clean.trim_start_matches('-');
542 match magnitude.parse::<u64>() {
543 Ok(v) => self.int(v, negative, start),
544 Err(_) => bad(self),
545 }
546 }
547 }
548
549 fn int(&mut self, magnitude: u64, negative: bool, start: usize) -> R<()> {
550 let v = if negative {
551 if magnitude == 1 << 63 {
552 i64::MIN
553 } else {
554 match i64::try_from(magnitude) {
555 Ok(v) => -v,
556 Err(_) => {
557 return err(self.pos(start), self.pos(self.i), SyntaxError::BadNumber);
558 }
559 }
560 }
561 } else {
562 match i64::try_from(magnitude) {
563 Ok(v) => v,
564 Err(_) => return err(self.pos(start), self.pos(self.i), SyntaxError::BadNumber),
565 }
566 };
567 self.push(T::Int(v), start, self.i);
568 Ok(())
569 }
570
571 fn escape(&mut self, start: usize) -> R<char> {
573 let c = self.at(self.i);
574 self.i += 1;
575 let simple = match c {
576 b'n' => Some('\n'),
577 b'r' => Some('\r'),
578 b't' => Some('\t'),
579 b'0' => Some('\0'),
580 b'\\' => Some('\\'),
581 b'"' => Some('"'),
582 b'\'' => Some('\''),
583 _ => None,
584 };
585 if let Some(ch) = simple {
586 return Ok(ch);
587 }
588 if c == b'u' && self.at(self.i) == b'{' {
589 self.i += 1;
590 let from = self.i;
591 while self.at(self.i).is_ascii_hexdigit() && self.i - from < 6 {
592 self.i += 1;
593 }
594 let hex = self.text.get(from..self.i).unwrap_or("");
595 if self.at(self.i) == b'}' && !hex.is_empty() {
596 self.i += 1;
597 if let Some(ch) = u32::from_str_radix(hex, 16).ok().and_then(char::from_u32) {
598 return Ok(ch);
599 }
600 }
601 }
602 err(self.pos(start), self.pos(self.i), SyntaxError::BadEscape)
603 }
604
605 fn string(&mut self) -> R<()> {
606 let start = self.i;
607 self.i += 1;
608 let mut out = String::new();
609 loop {
610 if self.i >= self.bytes.len() {
611 return err(self.pos(start), self.pos(self.i), SyntaxError::Unterminated);
612 }
613 match self.at(self.i) {
614 b'"' => {
615 self.i += 1;
616 break;
617 }
618 b'\\' => {
619 let at = self.i;
620 self.i += 1;
621 let ch = self.escape(at)?;
622 out.push(ch);
623 }
624 _ => {
625 let ch = self.text.get(self.i..).and_then(|r| r.chars().next());
626 match ch {
627 Some(ch) => {
628 out.push(ch);
629 self.i += ch.len_utf8();
630 }
631 None => {
632 return err(
633 self.pos(start),
634 self.pos(self.i),
635 SyntaxError::Unterminated,
636 );
637 }
638 }
639 }
640 }
641 }
642 let index = u32::try_from(self.strs.len()).unwrap_or(u32::MAX);
643 self.strs.push(out);
644 self.push(T::Str(index), start, self.i);
645 Ok(())
646 }
647
648 fn quote(&mut self) -> R<()> {
650 let start = self.i;
651 self.i += 1;
652 if self.at(self.i) == b'\\' {
653 let at = self.i;
654 self.i += 1;
655 let ch = self.escape(at)?;
656 return self.close_char(start, ch);
657 }
658 let Some(ch) = self.text.get(self.i..).and_then(|r| r.chars().next()) else {
659 return err(self.pos(start), self.pos(self.i), SyntaxError::Unterminated);
660 };
661 if self.at(self.i + ch.len_utf8()) == b'\'' {
662 self.i += ch.len_utf8();
663 return self.close_char(start, ch);
664 }
665 if !ident_start(self.at(self.i)) {
666 return err(
667 self.pos(start),
668 self.pos(self.i),
669 SyntaxError::Expected("a label name or a character literal"),
670 );
671 }
672 while ident_char(self.at(self.i)) {
673 self.i += 1;
674 }
675 if self.at(self.i) == b'%' {
676 return err(self.pos(start), self.pos(self.i + 1), SyntaxError::BinderId);
677 }
678 if self.at(self.i) == b'\'' {
679 return err(
680 self.pos(start),
681 self.pos(self.i + 1),
682 SyntaxError::Expected("one character between quotes"),
683 );
684 }
685 self.push(T::Label, start, self.i);
686 Ok(())
687 }
688
689 fn close_char(&mut self, start: usize, ch: char) -> R<()> {
690 if self.at(self.i) != b'\'' {
691 return err(self.pos(start), self.pos(self.i), SyntaxError::Unterminated);
692 }
693 self.i += 1;
694 self.push(T::Char(ch), start, self.i);
695 Ok(())
696 }
697}
698
699#[derive(Clone, Copy)]
703enum Named {
704 Plain(OpKind),
705 Conv(fn(Prim) -> OpKind),
706}
707
708fn op_named(name: &str) -> Option<Named> {
709 use Named::{Conv, Plain};
710 Some(match name {
711 "add" => Plain(OpKind::Add),
712 "sub" => Plain(OpKind::Sub),
713 "mul" => Plain(OpKind::Mul),
714 "neg" => Plain(OpKind::Neg),
715 "abs" => Plain(OpKind::Abs),
716 "div" => Plain(OpKind::Div),
717 "floor_div" => Plain(OpKind::FloorDiv),
718 "rem" => Plain(OpKind::Rem),
719 "floor_mod" => Plain(OpKind::FloorMod),
720 "and" => Plain(OpKind::And),
721 "or" => Plain(OpKind::Or),
722 "xor" => Plain(OpKind::Xor),
723 "not" => Plain(OpKind::Not),
724 "bit_not" => Plain(OpKind::BitNot),
725 "shl" => Plain(OpKind::Shl),
726 "shr" => Plain(OpKind::Shr),
727 "pow" => Plain(OpKind::Pow),
728 "eq" => Plain(OpKind::Eq),
729 "ne" => Plain(OpKind::Ne),
730 "lt" => Plain(OpKind::Lt),
731 "le" => Plain(OpKind::Le),
732 "gt" => Plain(OpKind::Gt),
733 "ge" => Plain(OpKind::Ge),
734 "min" => Plain(OpKind::Min),
735 "max" => Plain(OpKind::Max),
736 "ieee_rem" => Plain(OpKind::IeeeRem),
737 "sqrt" => Plain(OpKind::Sqrt),
738 "fma" => Plain(OpKind::Fma),
739 "floor" => Plain(OpKind::Floor),
740 "ceil" => Plain(OpKind::Ceil),
741 "trunc" => Plain(OpKind::Trunc),
742 "round" => Plain(OpKind::Round),
743 "round_even" => Plain(OpKind::RoundEven),
744 "total_cmp" => Plain(OpKind::TotalCmp),
745 "f32_to_f64" => Plain(OpKind::F32ToF64),
746 "f64_to_f32" => Plain(OpKind::F64ToF32),
747 "char_from_u32" => Plain(OpKind::CharFromU32),
748 "int_cast" => Conv(OpKind::IntCast),
749 "float_to_int" => Conv(OpKind::FloatToInt),
750 "zext" => Conv(OpKind::Zext),
751 "sext" => Conv(OpKind::Sext),
752 "narrow" => Conv(OpKind::Narrow),
753 "int_to_float" => Conv(OpKind::IntToFloat),
754 "bitcast" => Conv(OpKind::Bitcast),
755 "bool_to_int" => Conv(OpKind::BoolToInt),
756 _ => return None,
757 })
758}
759
760fn prim_named(name: &str) -> Option<Prim> {
761 Some(match name {
762 "bool" => Prim::Bool,
763 "i8" => Prim::I8,
764 "i16" => Prim::I16,
765 "i32" => Prim::I32,
766 "i64" => Prim::I64,
767 "isize" => Prim::Isize,
768 "u8" => Prim::U8,
769 "u16" => Prim::U16,
770 "u32" => Prim::U32,
771 "u64" => Prim::U64,
772 "usize" => Prim::Usize,
773 "f32" => Prim::F32,
774 "f64" => Prim::F64,
775 "char" => Prim::Char,
776 "str" => Prim::Str,
777 _ => return None,
778 })
779}
780
781fn reserved(word: &str) -> bool {
783 matches!(
784 word,
785 "let"
786 | "let_place"
787 | "in"
788 | "if"
789 | "else"
790 | "match"
791 | "loop"
792 | "break"
793 | "continue"
794 | "return"
795 | "throw"
796 | "await"
797 | "yield"
798 | "from"
799 | "spawn"
800 | "closure"
801 | "defer"
802 | "mut"
803 | "true"
804 | "false"
805 | "null"
806 | "_"
807 )
808}
809
810const BUILTIN_NAMES: [(&str, &str); 11] = [
813 ("while", "while"),
814 ("do_while", "do-while"),
815 ("c_for", "for"),
816 ("for_each", "foreach"),
817 ("logical_and", "&&"),
818 ("logical_or", "||"),
819 ("and_value", "and"),
820 ("or_value", "or"),
821 ("coalesce", "??"),
822 ("try", "?"),
823 ("post_increment", "post++"),
824];
825
826#[derive(Clone, Copy)]
830pub(crate) struct Registry<'a> {
831 pub(crate) templates: &'a [Template],
832 pub(crate) by_name: &'a BTreeMap<alloc::boxed::Box<str>, u32>,
833}
834
835impl<'a> Registry<'a> {
836 fn find(&self, name: &str) -> Option<(TemplateId, &'a Template)> {
837 let builtin = BUILTIN_NAMES
838 .iter()
839 .find(|(lsf, _)| *lsf == name)
840 .map(|(_, registered)| *registered);
841 let index = self.by_name.get(name).copied().or_else(|| {
842 let registered = builtin?;
843 let i = self.by_name.get(registered).copied()?;
844 let t = self.templates.get(i as usize)?;
846 (t.kind == hir_lang::ExpnKind::Desugar).then_some(i)
847 })?;
848 self.templates
849 .get(index as usize)
850 .map(|t| (TemplateId(index), t))
851 }
852}
853
854#[derive(Clone, Copy)]
857struct HoleInfo {
858 index: u16,
859 kind: HoleKind,
860 suffixed: bool,
862 suffix: Suffix,
863}
864
865struct Parser<'a> {
866 text: &'a str,
867 toks: Vec<Tok>,
868 strs: Vec<String>,
869 pos: usize,
870 b: TemplateBuilder,
871 holes: BTreeMap<&'a str, HoleInfo>,
872 scope: BTreeMap<&'a str, Vec<TBinder>>,
873 scope_log: Vec<&'a str>,
874 labels: BTreeMap<&'a str, Vec<TLabel>>,
875 label_log: Vec<&'a str>,
876 pending: Vec<(&'a str, TBinder, u32, u32)>,
878 depth: u32,
879 registry: Option<Registry<'a>>,
880}
881
882pub(crate) fn parse(
884 name: &str,
885 text: &str,
886 registry: Option<Registry<'_>>,
887) -> Result<Template, TemplateError> {
888 if text.len() > MAX_TEMPLATE_TEXT {
889 let end = u32::try_from(MAX_TEMPLATE_TEXT).unwrap_or(u32::MAX);
890 return err(0, end, SyntaxError::TooLong);
891 }
892 let (toks, strs) = Lexer::run(text)?;
893 let mut p = Parser {
894 text,
895 toks,
896 strs,
897 pos: 0,
898 b: TemplateBuilder::new(name),
899 holes: BTreeMap::new(),
900 scope: BTreeMap::new(),
901 scope_log: Vec::new(),
902 labels: BTreeMap::new(),
903 label_log: Vec::new(),
904 pending: Vec::new(),
905 depth: 0,
906 registry,
907 };
908 let root = p.expr()?;
909 let end = p.peek();
910 if end.t != T::Eof {
911 return err(
912 end.s,
913 end.e,
914 SyntaxError::Expected("the end of the template"),
915 );
916 }
917 p.b.finish(root)
918}
919
920impl<'a> Parser<'a> {
921 fn peek(&self) -> Tok {
924 self.peek_at(0)
925 }
926
927 fn peek_at(&self, n: usize) -> Tok {
928 let last = self.toks.last().copied().unwrap_or(Tok {
929 t: T::Eof,
930 s: 0,
931 e: 0,
932 });
933 self.toks
934 .get(self.pos.saturating_add(n))
935 .copied()
936 .unwrap_or(last)
937 }
938
939 fn bump(&mut self) -> Tok {
940 let t = self.peek();
941 if self.pos < self.toks.len() {
942 self.pos += 1;
943 }
944 t
945 }
946
947 fn word(&self, t: Tok) -> &'a str {
948 self.text.get(t.s as usize..t.e as usize).unwrap_or("")
949 }
950
951 fn is_p(&self, c: u8) -> bool {
952 self.peek().t == T::P(c)
953 }
954
955 fn eat_p(&mut self, c: u8) -> bool {
956 if self.is_p(c) {
957 let _ = self.bump();
958 true
959 } else {
960 false
961 }
962 }
963
964 fn expect_p(&mut self, c: u8, what: &'static str) -> R<Tok> {
965 let t = self.peek();
966 if t.t == T::P(c) {
967 Ok(self.bump())
968 } else {
969 err(t.s, t.e, SyntaxError::Expected(what))
970 }
971 }
972
973 fn is_kw(&self, kw: &str) -> bool {
974 let t = self.peek();
975 t.t == T::Ident && self.word(t) == kw
976 }
977
978 fn eat_kw(&mut self, kw: &str) -> bool {
979 if self.is_kw(kw) {
980 let _ = self.bump();
981 true
982 } else {
983 false
984 }
985 }
986
987 fn expect_kw(&mut self, kw: &str, what: &'static str) -> R<()> {
988 if self.eat_kw(kw) {
989 Ok(())
990 } else {
991 let t = self.peek();
992 err(t.s, t.e, SyntaxError::Expected(what))
993 }
994 }
995
996 fn prev(&self) -> Option<Tok> {
998 self.pos
999 .checked_sub(1)
1000 .and_then(|i| self.toks.get(i))
1001 .copied()
1002 }
1003
1004 fn enter(&mut self) -> R<()> {
1006 self.depth += 1;
1007 if self.depth > MAX_TEMPLATE_DEPTH {
1008 let t = self.peek();
1009 return err(t.s, t.e, SyntaxError::TooDeep);
1010 }
1011 Ok(())
1012 }
1013
1014 fn leave(&mut self) {
1015 self.depth = self.depth.saturating_sub(1);
1016 }
1017
1018 fn starts_expr(&self) -> bool {
1021 let t = self.peek();
1022 match t.t {
1023 T::Int(_)
1024 | T::Float(_)
1025 | T::Str(_)
1026 | T::Char(_)
1027 | T::Label
1028 | T::Free(_)
1029 | T::Hole { splice: false, .. } => true,
1030 T::P(c) => matches!(c, b'(' | b'[' | b'{'),
1031 T::Ident => !matches!(self.word(t), "else" | "in" | "from"),
1032 T::Hole { splice: true, .. } | T::Arrow | T::Eof => false,
1033 }
1034 }
1035
1036 fn scope_mark(&self) -> (usize, usize) {
1039 (self.scope_log.len(), self.label_log.len())
1040 }
1041
1042 fn scope_pop(&mut self, mark: (usize, usize)) {
1043 while self.scope_log.len() > mark.0 {
1044 if let Some(name) = self.scope_log.pop() {
1045 if let Some(stack) = self.scope.get_mut(name) {
1046 let _ = stack.pop();
1047 }
1048 }
1049 }
1050 while self.label_log.len() > mark.1 {
1051 if let Some(name) = self.label_log.pop() {
1052 if let Some(stack) = self.labels.get_mut(name) {
1053 let _ = stack.pop();
1054 }
1055 }
1056 }
1057 }
1058
1059 fn bind_name(&mut self, name: &'a str, b: TBinder) {
1060 self.scope.entry(name).or_default().push(b);
1061 self.scope_log.push(name);
1062 }
1063
1064 fn commit(&mut self, from: usize) -> R<()> {
1067 let mut fresh: Vec<(&'a str, TBinder, u32, u32)> = self.pending.split_off(from);
1068 let mut sorted: Vec<(&'a str, u32, u32)> =
1069 fresh.iter().map(|&(n, _, s, e)| (n, s, e)).collect();
1070 sorted.sort_by(|a, b| a.0.cmp(b.0).then(a.1.cmp(&b.1)));
1071 if let Some(w) = sorted.windows(2).find(|w| w[0].0 == w[1].0) {
1072 return err(w[1].1, w[1].2, SyntaxError::BoundTwice);
1073 }
1074 for (name, b, _, _) in fresh.drain(..) {
1075 self.bind_name(name, b);
1076 }
1077 Ok(())
1078 }
1079
1080 fn lookup(&self, name: &str) -> Option<TBinder> {
1081 self.scope.get(name).and_then(|s| s.last().copied())
1082 }
1083
1084 fn binder_name(&mut self) -> R<(&'a str, Tok)> {
1086 let t = self.peek();
1087 let word = self.word(t);
1088 if t.t != T::Ident || reserved(word) {
1089 return err(t.s, t.e, SyntaxError::Expected("a binder name"));
1090 }
1091 let _ = self.bump();
1092 Ok((word, t))
1093 }
1094
1095 fn hole(&mut self, t: Tok, kind: HoleKind) -> R<u16> {
1099 let T::Hole { name, suffix, .. } = t.t else {
1100 return err(t.s, t.e, SyntaxError::Expected("a hole"));
1101 };
1102 let name = self
1103 .text
1104 .get(name.0 as usize..name.1 as usize)
1105 .unwrap_or("");
1106 if matches!(suffix, Suffix::Default(_)) && kind != HoleKind::Expr {
1107 return err(t.s, t.e, SyntaxError::HoleDefault);
1108 }
1109 if let Some(info) = self.holes.get(name).copied() {
1110 if info.kind != kind {
1111 return err(
1112 t.s,
1113 t.e,
1114 SyntaxError::HoleKind {
1115 first: info.kind,
1116 here: kind,
1117 },
1118 );
1119 }
1120 if suffix != Suffix::None {
1121 if info.suffixed && info.suffix != suffix {
1122 return err(t.s, t.e, SyntaxError::HoleSuffix);
1123 }
1124 self.set_suffix(name, info, suffix);
1125 }
1126 return Ok(info.index);
1127 }
1128 let optional = suffix != Suffix::None;
1129 let index = match kind {
1130 HoleKind::Expr => match suffix {
1131 Suffix::None => self.b.expr_hole(name).0,
1132 Suffix::Optional => self.b.optional_expr_hole(name, None).0,
1133 Suffix::Default(lit) => self.b.optional_expr_hole(name, Some(lit)).0,
1134 },
1135 HoleKind::Pat => self.b.pat_hole(name, optional).0,
1136 HoleKind::Ty => self.b.ty_hole(name, optional).0,
1137 HoleKind::Stmts => self.b.stmts_hole(name).0,
1138 HoleKind::Args => self.b.args_hole(name).0,
1139 HoleKind::Label => self.b.label_hole(name).0,
1140 };
1141 let _ = self.holes.insert(
1142 name,
1143 HoleInfo {
1144 index,
1145 kind,
1146 suffixed: optional,
1147 suffix,
1148 },
1149 );
1150 Ok(index)
1151 }
1152
1153 fn set_suffix(&mut self, name: &'a str, info: HoleInfo, suffix: Suffix) {
1156 if let Some(decl) = self.b.t.holes.get_mut(usize::from(info.index)) {
1157 if matches!(info.kind, HoleKind::Expr | HoleKind::Pat | HoleKind::Ty) {
1158 decl.optional = true;
1159 }
1160 if let Suffix::Default(lit) = suffix {
1161 decl.default = Some(lit);
1162 }
1163 }
1164 let _ = self.holes.insert(
1165 name,
1166 HoleInfo {
1167 suffixed: true,
1168 suffix,
1169 ..info
1170 },
1171 );
1172 }
1173
1174 fn hole_kind(&self, t: Tok) -> Option<HoleKind> {
1175 let T::Hole { name, .. } = t.t else {
1176 return None;
1177 };
1178 let name = self
1179 .text
1180 .get(name.0 as usize..name.1 as usize)
1181 .unwrap_or("");
1182 self.holes.get(name).map(|h| h.kind)
1183 }
1184
1185 fn expr(&mut self) -> R<TExpr> {
1188 self.enter()?;
1189 let e = self.expr_inner();
1190 self.leave();
1191 e
1192 }
1193
1194 fn expr_inner(&mut self) -> R<TExpr> {
1195 let t = self.peek();
1196 if t.t == T::Ident {
1197 match self.word(t) {
1198 "return" => {
1199 let _ = self.bump();
1200 let v = self.opt_value()?;
1201 return Ok(self.b.return_(v));
1202 }
1203 "throw" => {
1204 let _ = self.bump();
1205 let v = self.expr()?;
1206 return Ok(self.b.throw(v));
1207 }
1208 "await" => {
1209 let _ = self.bump();
1210 let v = self.expr()?;
1211 return Ok(self.b.await_(v));
1212 }
1213 "spawn" => {
1214 let _ = self.bump();
1215 let v = self.expr()?;
1216 return Ok(self.b.spawn(v));
1217 }
1218 "yield" => return self.yield_expr(),
1219 "break" => return self.break_expr(),
1220 "continue" => return self.continue_expr(),
1221 "let_place" => return self.let_place(),
1222 _ => {}
1223 }
1224 }
1225 let lhs = self.postfix()?;
1226 if self.eat_p(b'=') {
1227 let rhs = self.expr()?;
1228 return Ok(self.b.assign(lhs, rhs));
1229 }
1230 Ok(lhs)
1231 }
1232
1233 fn opt_value(&mut self) -> R<Option<TExpr>> {
1234 if self.starts_expr() {
1235 Ok(Some(self.expr()?))
1236 } else {
1237 Ok(None)
1238 }
1239 }
1240
1241 fn yield_expr(&mut self) -> R<TExpr> {
1242 let _ = self.bump();
1243 if self.eat_kw("from") {
1244 let source = self.expr()?;
1245 return Ok(self.b.yield_from(source));
1246 }
1247 if !self.starts_expr() {
1248 return Ok(self.b.yield_(None));
1249 }
1250 let first = self.expr()?;
1251 if self.peek().t == T::Arrow {
1252 let _ = self.bump();
1253 let value = self.expr()?;
1254 return Ok(self.b.yield_kv(first, value));
1255 }
1256 Ok(self.b.yield_(Some(first)))
1257 }
1258
1259 fn break_expr(&mut self) -> R<TExpr> {
1260 let _ = self.bump();
1261 let t = self.peek();
1262 let label = match t.t {
1263 T::Label => Some(self.label_use()?),
1264 T::Hole { splice: false, .. } if self.hole_kind(t) == Some(HoleKind::Label) => {
1265 let _ = self.bump();
1266 Some(LabelRef::Hole(LabelHole(self.hole(t, HoleKind::Label)?)))
1267 }
1268 _ => None,
1269 };
1270 let value = self.opt_value()?;
1271 Ok(self.b.break_(label, value))
1272 }
1273
1274 fn continue_expr(&mut self) -> R<TExpr> {
1275 let _ = self.bump();
1276 let t = self.peek();
1277 let label = match t.t {
1278 T::Label => Some(self.label_use()?),
1279 T::Hole { splice: false, .. } => {
1280 let _ = self.bump();
1281 Some(LabelRef::Hole(LabelHole(self.hole(t, HoleKind::Label)?)))
1282 }
1283 _ => None,
1284 };
1285 Ok(self.b.continue_(label))
1286 }
1287
1288 fn label_use(&mut self) -> R<LabelRef> {
1290 let t = self.bump();
1291 let name = self.word(t).get(1..).unwrap_or("");
1292 match self.labels.get(name).and_then(|s| s.last().copied()) {
1293 Some(l) => Ok(LabelRef::Own(l)),
1294 None => err(t.s, t.e, SyntaxError::UnknownLabel),
1295 }
1296 }
1297
1298 fn let_place(&mut self) -> R<TExpr> {
1300 let _ = self.bump();
1301 let (name, _) = self.binder_name()?;
1302 let _ = self.expect_p(b'=', "`=` after the place alias")?;
1303 let place = self.postfix()?;
1304 self.expect_kw("in", "`in` after the place")?;
1305 let alias = self.b.binder(name);
1306 let mark = self.scope_mark();
1307 self.bind_name(name, alias);
1308 let body = self.expr();
1309 self.scope_pop(mark);
1310 let body = body?;
1311 Ok(self.b.let_place(alias, place, body))
1312 }
1313
1314 fn postfix(&mut self) -> R<TExpr> {
1315 let mut e = self.primary()?;
1316 loop {
1317 if self.is_p(b'(') {
1318 let _ = self.bump();
1319 let args = self.list(b')')?;
1320 e = self.b.call(e, &args);
1321 } else if self.is_p(b'.') {
1322 let _ = self.bump();
1323 let t = self.peek();
1324 if t.t != T::Ident {
1325 return err(t.s, t.e, SyntaxError::Expected("a field or method name"));
1326 }
1327 let _ = self.bump();
1328 let name = self.word(t);
1329 if self.is_p(b'(') {
1330 let _ = self.bump();
1331 let args = self.list(b')')?;
1332 e = self.b.method(e, name, &args);
1333 } else {
1334 e = self.b.field(e, name);
1335 }
1336 } else if self.is_p(b'[') {
1337 let _ = self.bump();
1338 let i = self.expr()?;
1339 let _ = self.expect_p(b']', "`]` closing the index")?;
1340 e = self.b.index(e, i);
1341 } else {
1342 return Ok(e);
1343 }
1344 }
1345 }
1346
1347 fn list(&mut self, close: u8) -> R<Vec<TExpr>> {
1350 let mut out = Vec::new();
1351 loop {
1352 if self.eat_p(close) {
1353 return Ok(out);
1354 }
1355 let t = self.peek();
1356 if let T::Hole { splice: true, .. } = t.t {
1357 let _ = self.bump();
1358 let h = self.hole(t, HoleKind::Args)?;
1359 out.push(self.b.splice(ArgsHole(h)));
1360 } else {
1361 out.push(self.expr()?);
1362 }
1363 if !self.eat_p(b',') {
1364 let t = self.peek();
1365 if t.t != T::P(close) {
1366 return err(t.s, t.e, SyntaxError::Expected("`,` or a closing bracket"));
1367 }
1368 }
1369 }
1370 }
1371
1372 fn primary(&mut self) -> R<TExpr> {
1373 let t = self.peek();
1374 match t.t {
1375 T::Int(v) => {
1376 let _ = self.bump();
1377 Ok(self.b.lit(TLit::Int(v)))
1378 }
1379 T::Float(v) => {
1380 let _ = self.bump();
1381 Ok(self.b.lit(TLit::Float(v)))
1382 }
1383 T::Char(c) => {
1384 let _ = self.bump();
1385 Ok(self.b.lit(TLit::Char(c)))
1386 }
1387 T::Str(i) => {
1388 let _ = self.bump();
1389 let text = self.strs.get(i as usize).map_or("", String::as_str);
1390 let text: String = String::from(text);
1391 Ok(self.b.str(&text))
1392 }
1393 T::Hole { splice: true, .. } => err(t.s, t.e, SyntaxError::SpliceHere),
1394 T::Hole { .. } => {
1395 let _ = self.bump();
1396 if self.is_kw("loop") {
1397 let h = self.hole(t, HoleKind::Label)?;
1398 return self.loop_expr(Some(LabelRef::Hole(LabelHole(h))));
1399 }
1400 let h = self.hole(t, HoleKind::Expr)?;
1401 Ok(self.b.hole(ExprHole(h)))
1402 }
1403 T::Label => self.labeled(),
1404 T::Free(kind) => {
1405 let _ = self.bump();
1406 let path = self.word(t).split_once(':').map_or("", |(_, p)| p);
1407 match kind {
1408 Free::Extern => Ok(self.b.extern_(path)),
1409 Free::Global => {
1410 check_path(path, t)?;
1411 Ok(self.b.global(path))
1412 }
1413 Free::Apply => self.apply(path, t),
1414 }
1415 }
1416 T::P(b'(') => self.paren(),
1417 T::P(b'[') => {
1418 let _ = self.bump();
1419 let elems = self.list(b']')?;
1420 Ok(self.b.array(&elems))
1421 }
1422 T::P(b'{') => self.block(),
1423 T::Ident => self.word_expr(t),
1424 _ => err(t.s, t.e, SyntaxError::Expected("an expression")),
1425 }
1426 }
1427
1428 fn word_expr(&mut self, t: Tok) -> R<TExpr> {
1429 let word = self.word(t);
1430 match word {
1431 "true" | "false" => {
1432 let _ = self.bump();
1433 Ok(self.b.lit(TLit::Bool(word == "true")))
1434 }
1435 "null" => {
1436 let _ = self.bump();
1437 Ok(self.b.lit(TLit::Null))
1438 }
1439 "if" => self.if_expr(),
1440 "match" => self.match_expr(),
1441 "loop" => self.loop_expr(None),
1442 "closure" => self.closure(),
1443 _ => {
1444 let next = self.peek_at(1).t;
1445 if matches!(next, T::P(b'(' | b'<')) {
1446 if let Some(named) = op_named(word) {
1447 return self.op(named, t);
1448 }
1449 }
1450 if let Some(b) = self.lookup(word) {
1451 let _ = self.bump();
1452 return Ok(self.b.var(b));
1453 }
1454 if reserved(word) {
1455 return err(t.s, t.e, SyntaxError::Expected("an expression"));
1456 }
1457 if next == T::P(b'(') {
1458 return err(t.s, t.e, SyntaxError::UnknownOp);
1459 }
1460 err(t.s, t.e, SyntaxError::UnknownName)
1461 }
1462 }
1463 }
1464
1465 fn paren(&mut self) -> R<TExpr> {
1467 let _ = self.bump();
1468 if self.eat_p(b')') {
1469 return Ok(self.b.tuple(&[]));
1470 }
1471 if let T::Hole { splice: true, .. } = self.peek().t {
1472 let elems = self.list(b')')?;
1473 return Ok(self.b.tuple(&elems));
1474 }
1475 let first = self.expr()?;
1476 if self.eat_p(b')') {
1477 return Ok(first);
1478 }
1479 let _ = self.expect_p(b',', "`,` or `)`")?;
1480 let mut elems = alloc::vec![first];
1481 elems.extend(self.list(b')')?);
1482 Ok(self.b.tuple(&elems))
1483 }
1484
1485 fn labeled(&mut self) -> R<TExpr> {
1487 let t = self.bump();
1488 let name = self.word(t).get(1..).unwrap_or("");
1489 let label = self.b.label(name);
1490 let mark = self.scope_mark();
1491 self.labels.entry(name).or_default().push(label);
1492 self.label_log.push(name);
1493 let out = if self.is_kw("loop") {
1494 self.loop_expr(Some(LabelRef::Own(label)))
1495 } else if self.is_p(b'{') {
1496 self.labeled_block(label)
1497 } else {
1498 let n = self.peek();
1499 err(
1500 n.s,
1501 n.e,
1502 SyntaxError::Expected("`loop` or a block after the label"),
1503 )
1504 };
1505 self.scope_pop(mark);
1506 out
1507 }
1508
1509 fn labeled_block(&mut self, label: TLabel) -> R<TExpr> {
1510 self.enter()?;
1511 let parts = self.block_parts();
1512 self.leave();
1513 let (stmts, tail) = parts?;
1514 Ok(self.b.labeled_block(LabelRef::Own(label), &stmts, tail))
1515 }
1516
1517 fn block(&mut self) -> R<TExpr> {
1518 self.enter()?;
1519 let parts = self.block_parts();
1520 self.leave();
1521 let (stmts, tail) = parts?;
1522 Ok(self.b.block(&stmts, tail))
1523 }
1524
1525 fn starts_blocklike(&self) -> bool {
1528 let t = self.peek();
1529 match t.t {
1530 T::P(b'{') | T::Label => true,
1531 T::Ident => matches!(self.word(t), "if" | "match" | "loop"),
1532 T::Hole { splice: false, .. } => {
1533 let n = self.peek_at(1);
1534 n.t == T::Ident && self.word(n) == "loop"
1535 }
1536 _ => false,
1537 }
1538 }
1539
1540 fn block_parts(&mut self) -> R<(Vec<TStmt>, Option<TExpr>)> {
1541 let _ = self.expect_p(b'{', "`{`")?;
1542 let mark = self.scope_mark();
1543 let out = self.stmts();
1544 self.scope_pop(mark);
1545 out
1546 }
1547
1548 fn stmts(&mut self) -> R<(Vec<TStmt>, Option<TExpr>)> {
1549 let mut stmts = Vec::new();
1550 loop {
1551 if self.eat_p(b'}') {
1552 return Ok((stmts, None));
1553 }
1554 if self.eat_p(b';') {
1555 continue;
1556 }
1557 let t = self.peek();
1558 if t.t == T::Eof {
1559 return err(t.s, t.e, SyntaxError::Expected("`}` closing the block"));
1560 }
1561 if self.is_kw("let") {
1562 stmts.push(self.let_stmt()?);
1563 continue;
1564 }
1565 if self.eat_kw("defer") {
1566 let e = self.expr()?;
1567 stmts.push(self.b.defer(e));
1568 if !self.eat_p(b';') && !self.is_p(b'}') {
1569 let n = self.peek();
1570 return err(n.s, n.e, SyntaxError::Expected("`;` or `}`"));
1571 }
1572 continue;
1573 }
1574 if let T::Hole { splice: true, .. } = t.t {
1575 let _ = self.bump();
1576 let h = self.hole(t, HoleKind::Stmts)?;
1577 stmts.push(self.b.stmts(StmtsHole(h)));
1578 let _ = self.eat_p(b';');
1579 continue;
1580 }
1581 let blocky = self.starts_blocklike();
1582 let e = if blocky {
1584 self.blocklike()?
1585 } else {
1586 self.expr()?
1587 };
1588 if self.eat_p(b';') {
1589 stmts.push(self.b.expr_stmt(e));
1590 } else if self.eat_p(b'}') {
1591 return Ok((stmts, Some(e)));
1592 } else if blocky {
1593 stmts.push(self.b.expr_stmt(e));
1594 } else {
1595 let n = self.peek();
1596 return err(n.s, n.e, SyntaxError::Expected("`;` or `}`"));
1597 }
1598 }
1599 }
1600
1601 fn blocklike(&mut self) -> R<TExpr> {
1604 let t = self.peek();
1605 match t.t {
1606 T::P(b'{') => self.block(),
1607 T::Label => self.labeled(),
1608 T::Hole { .. } => {
1609 let _ = self.bump();
1610 let h = self.hole(t, HoleKind::Label)?;
1611 self.loop_expr(Some(LabelRef::Hole(LabelHole(h))))
1612 }
1613 _ => match self.word(t) {
1614 "if" => self.if_expr(),
1615 "match" => self.match_expr(),
1616 _ => self.loop_expr(None),
1617 },
1618 }
1619 }
1620
1621 fn let_stmt(&mut self) -> R<TStmt> {
1624 let _ = self.bump();
1625 let from = self.pending.len();
1626 let pat = self.pat()?;
1627 let ty = if self.eat_p(b':') {
1628 Some(self.ty()?)
1629 } else {
1630 None
1631 };
1632 let init = if self.eat_p(b'=') {
1633 Some(self.expr()?)
1634 } else {
1635 None
1636 };
1637 let _ = self.expect_p(b';', "`;` after `let`")?;
1638 self.commit(from)?;
1639 Ok(self.b.let_(pat, ty, init))
1640 }
1641
1642 fn if_expr(&mut self) -> R<TExpr> {
1643 self.enter()?;
1644 let out = self.if_inner();
1645 self.leave();
1646 out
1647 }
1648
1649 fn if_inner(&mut self) -> R<TExpr> {
1650 let _ = self.bump();
1651 let cond = self.expr()?;
1652 if !self.is_p(b'{') {
1653 let t = self.peek();
1654 return err(
1655 t.s,
1656 t.e,
1657 SyntaxError::Expected("a block after the condition"),
1658 );
1659 }
1660 let then = self.block()?;
1661 let else_ = if self.eat_kw("else") {
1662 if self.is_kw("if") {
1663 Some(self.if_expr()?)
1664 } else if self.is_p(b'{') {
1665 Some(self.block()?)
1666 } else {
1667 let t = self.peek();
1668 return err(
1669 t.s,
1670 t.e,
1671 SyntaxError::Expected("a block or `if` after `else`"),
1672 );
1673 }
1674 } else {
1675 None
1676 };
1677 Ok(self.b.if_(cond, then, else_))
1678 }
1679
1680 fn match_expr(&mut self) -> R<TExpr> {
1681 let _ = self.bump();
1682 let scrutinee = self.expr()?;
1683 let _ = self.expect_p(b'{', "`{` opening the arms")?;
1684 let mut arms = Vec::new();
1685 loop {
1686 if self.eat_p(b'}') {
1687 break;
1688 }
1689 let from = self.pending.len();
1690 let pat = self.pat()?;
1691 let mark = self.scope_mark();
1692 if let Err(e) = self.commit(from) {
1693 self.scope_pop(mark);
1694 return Err(e);
1695 }
1696 let arm = self.arm_rest();
1697 self.scope_pop(mark);
1698 let (guard, body) = arm?;
1699 arms.push((pat, guard, body));
1700 if self.eat_p(b',') || self.is_p(b'}') {
1701 continue;
1702 }
1703 if self.prev().is_some_and(|p| p.t == T::P(b'}')) {
1705 continue;
1706 }
1707 let t = self.peek();
1708 return err(t.s, t.e, SyntaxError::Expected("`,` or `}` after the arm"));
1709 }
1710 Ok(self.b.match_(scrutinee, &arms))
1711 }
1712
1713 fn arm_rest(&mut self) -> R<(Option<TExpr>, TExpr)> {
1714 let guard = if self.eat_kw("if") {
1715 Some(self.expr()?)
1716 } else {
1717 None
1718 };
1719 let t = self.peek();
1720 if t.t != T::Arrow {
1721 return err(t.s, t.e, SyntaxError::Expected("`=>`"));
1722 }
1723 let _ = self.bump();
1724 let body = self.expr()?;
1725 Ok((guard, body))
1726 }
1727
1728 fn loop_expr(&mut self, label: Option<LabelRef>) -> R<TExpr> {
1730 self.expect_kw("loop", "`loop`")?;
1731 let step = if self.eat_p(b'[') {
1732 self.expect_kw("step", "`step`")?;
1733 let _ = self.expect_p(b':', "`:` after `step`")?;
1734 let s = self.expr()?;
1735 let _ = self.expect_p(b']', "`]` closing the step")?;
1736 Some(s)
1737 } else {
1738 None
1739 };
1740 if !self.is_p(b'{') {
1741 let t = self.peek();
1742 return err(t.s, t.e, SyntaxError::Expected("the loop's block"));
1743 }
1744 let body = self.block()?;
1745 Ok(self.b.loop_(label, body, step))
1746 }
1747
1748 fn closure(&mut self) -> R<TExpr> {
1751 let _ = self.bump();
1752 let mut mode = None;
1753 if self.eat_p(b'[') {
1754 let first = self.peek();
1755 let mut word = String::new();
1756 loop {
1757 let t = self.peek();
1758 if t.t != T::Ident {
1759 return err(t.s, t.e, SyntaxError::Expected("a capture mode"));
1760 }
1761 let _ = self.bump();
1762 word.push_str(self.word(t));
1763 if !self.eat_p(b'-') {
1764 break;
1765 }
1766 word.push('-');
1767 }
1768 let end = self.prev().map_or(first.e, |p| p.e);
1769 mode = match word.as_str() {
1770 "none" => None,
1771 "infer" => Some(CaptureMode::Infer),
1772 "by-ref" => Some(CaptureMode::ByRef),
1773 "by-mut-ref" => Some(CaptureMode::ByMutRef),
1774 "by-value" => Some(CaptureMode::ByValue),
1775 _ => {
1776 return err(
1777 first.s,
1778 end,
1779 SyntaxError::Expected(
1780 "`none`, `infer`, `by-ref`, `by-mut-ref`, or `by-value`",
1781 ),
1782 );
1783 }
1784 };
1785 let _ = self.expect_p(b']', "`]` closing the capture mode")?;
1786 }
1787 let _ = self.expect_p(b'(', "`(` opening the parameters")?;
1788 let from = self.pending.len();
1789 let mut params = Vec::new();
1790 loop {
1791 if self.eat_p(b')') {
1792 break;
1793 }
1794 let mutable = self.eat_kw("mut");
1795 let (name, t) = self.binder_name()?;
1796 let b = if mutable {
1797 self.b.mutable_binder(name)
1798 } else {
1799 self.b.binder(name)
1800 };
1801 self.pending.push((name, b, t.s, t.e));
1802 params.push(b);
1803 if !self.eat_p(b',') && !self.is_p(b')') {
1804 let n = self.peek();
1805 return err(n.s, n.e, SyntaxError::Expected("`,` or `)`"));
1806 }
1807 }
1808 let t = self.peek();
1809 if t.t != T::Arrow {
1810 return err(
1811 t.s,
1812 t.e,
1813 SyntaxError::Expected("`=>` before the closure body"),
1814 );
1815 }
1816 let _ = self.bump();
1817 let mark = self.scope_mark();
1818 if let Err(e) = self.commit(from) {
1819 self.scope_pop(mark);
1820 return Err(e);
1821 }
1822 let body = self.expr();
1823 self.scope_pop(mark);
1824 Ok(self.b.closure(¶ms, body?, mode))
1825 }
1826
1827 fn op(&mut self, named: Named, name_tok: Tok) -> R<TExpr> {
1829 let _ = self.bump();
1830 let mut target: Option<Prim> = None;
1831 let mut policy = hir_lang::Policy::NONE;
1832 let mut written = false;
1833 let mut bad: Option<Tok> = None;
1834 if self.eat_p(b'<') {
1835 loop {
1836 let key = self.peek();
1837 if key.t != T::Ident {
1838 return err(
1839 key.s,
1840 key.e,
1841 SyntaxError::Expected("a policy or a target type"),
1842 );
1843 }
1844 let _ = self.bump();
1845 if self.eat_p(b'=') {
1846 let value = self.peek();
1847 if value.t != T::Ident {
1848 return err(value.s, value.e, SyntaxError::Expected("a policy value"));
1849 }
1850 let _ = self.bump();
1851 let ok = set_policy(&mut policy, self.word(key), self.word(value));
1852 if !ok && bad.is_none() {
1853 bad = Some(Tok {
1854 t: T::Ident,
1855 s: key.s,
1856 e: value.e,
1857 });
1858 }
1859 written = true;
1860 } else {
1861 match prim_named(self.word(key)) {
1862 Some(p) if target.is_none() => target = Some(p),
1863 _ => {
1864 if bad.is_none() {
1865 bad = Some(key);
1866 }
1867 }
1868 }
1869 }
1870 if self.eat_p(b'>') {
1871 break;
1872 }
1873 let _ = self.expect_p(b',', "`,` or `>`")?;
1874 }
1875 }
1876 let kind = match (named, target) {
1877 (Named::Plain(k), None) => k,
1878 (Named::Conv(make), Some(p)) => make(p),
1879 (Named::Plain(_), Some(_)) => {
1880 return err(name_tok.s, name_tok.e, SyntaxError::BadPolicy);
1881 }
1882 (Named::Conv(_), None) => {
1883 return err(name_tok.s, name_tok.e, SyntaxError::UnknownOp);
1884 }
1885 };
1886 if let Some(b) = bad {
1887 return err(b.s, b.e, SyntaxError::BadPolicy);
1888 }
1889 let _ = self.expect_p(b'(', "`(` opening the operands")?;
1890 let mut args = Vec::new();
1891 loop {
1892 if self.eat_p(b')') {
1893 break;
1894 }
1895 let t = self.peek();
1896 if let T::Hole { splice: true, .. } = t.t {
1897 return err(t.s, t.e, SyntaxError::SpliceHere);
1898 }
1899 args.push(self.expr()?);
1900 if !self.eat_p(b',') && !self.is_p(b')') {
1901 let n = self.peek();
1902 return err(n.s, n.e, SyntaxError::Expected("`,` or `)`"));
1903 }
1904 }
1905 if args.len() != kind.arity() {
1906 return err(
1907 name_tok.s,
1908 name_tok.e,
1909 SyntaxError::Arity {
1910 expected: kind.arity(),
1911 found: args.len(),
1912 },
1913 );
1914 }
1915 if !written {
1916 return Ok(self.b.op(kind, &args));
1917 }
1918 let defaults = kind.default_policy();
1921 let fits = (policy.overflow.is_none() || defaults.overflow.is_some())
1922 && (policy.div_zero.is_none() || defaults.div_zero.is_some())
1923 && (policy.shift.is_none() || defaults.shift.is_some())
1924 && (policy.float_to_int.is_none() || defaults.float_to_int.is_some());
1925 if !fits {
1926 return err(name_tok.s, name_tok.e, SyntaxError::BadPolicy);
1927 }
1928 let op = Op {
1929 kind,
1930 policy: hir_lang::Policy {
1931 overflow: policy.overflow.or(defaults.overflow),
1932 div_zero: policy.div_zero.or(defaults.div_zero),
1933 shift: policy.shift.or(defaults.shift),
1934 float_to_int: policy.float_to_int.or(defaults.float_to_int),
1935 },
1936 };
1937 Ok(self.b.op_with(op, &args))
1938 }
1939
1940 fn apply(&mut self, name: &str, t: Tok) -> R<TExpr> {
1944 let Some((id, callee)) = self.registry.and_then(|r| r.find(name)) else {
1945 return err(t.s, t.e, SyntaxError::UnknownTemplate);
1946 };
1947 let _ = self.expect_p(b'(', "`(` after the template name")?;
1948 let mark = self.scope_mark();
1949 let out = self.apply_args(callee);
1950 self.scope_pop(mark);
1951 let args = out?;
1952 Ok(self.b.apply(id, &args))
1953 }
1954
1955 fn apply_args(&mut self, callee: &Template) -> R<Vec<TArg>> {
1956 let mut args = Vec::with_capacity(callee.holes.len());
1957 let mut closed = false;
1958 for (i, hole) in callee.holes.iter().enumerate() {
1959 let t = self.peek();
1960 if closed || t.t == T::P(b')') {
1961 if !hole.optional {
1962 return err(t.s, t.e, SyntaxError::ApplyArgs);
1963 }
1964 args.push(TArg::Absent);
1965 closed = true;
1966 continue;
1967 }
1968 let next = self.peek_at(1).t;
1969 let arg = if t.t == T::Ident
1970 && self.word(t) == "_"
1971 && matches!(next, T::P(b',' | b')'))
1972 && hole.kind != HoleKind::Pat
1973 {
1974 let _ = self.bump();
1975 if !hole.optional {
1976 return err(t.s, t.e, SyntaxError::ApplyArgs);
1977 }
1978 TArg::Absent
1979 } else {
1980 self.apply_arg(hole.kind, t)?
1981 };
1982 args.push(arg);
1983 if i + 1 < callee.holes.len() && !self.eat_p(b',') && !self.is_p(b')') {
1984 let n = self.peek();
1985 return err(n.s, n.e, SyntaxError::Expected("`,` or `)`"));
1986 }
1987 }
1988 let _ = self.eat_p(b',');
1989 let t = self.peek();
1990 if t.t != T::P(b')') {
1991 return err(t.s, t.e, SyntaxError::ApplyArgs);
1992 }
1993 let _ = self.bump();
1994 Ok(args)
1995 }
1996
1997 fn apply_arg(&mut self, kind: HoleKind, t: Tok) -> R<TArg> {
1998 match kind {
1999 HoleKind::Expr => {
2000 if let T::Hole { splice: true, .. } = t.t {
2001 return err(t.s, t.e, SyntaxError::ApplyArgs);
2002 }
2003 Ok(TArg::Expr(self.expr()?))
2004 }
2005 HoleKind::Pat => {
2006 let from = self.pending.len();
2008 let p = self.pat()?;
2009 self.commit(from)?;
2010 Ok(TArg::Pat(p))
2011 }
2012 HoleKind::Ty => Ok(TArg::Ty(self.ty()?)),
2013 HoleKind::Stmts | HoleKind::Args => match t.t {
2014 T::Hole { splice: true, .. } => {
2015 let _ = self.bump();
2016 let h = self.hole(t, kind)?;
2017 Ok(if kind == HoleKind::Stmts {
2018 TArg::Stmts(StmtsHole(h))
2019 } else {
2020 TArg::Args(ArgsHole(h))
2021 })
2022 }
2023 _ => err(t.s, t.e, SyntaxError::ApplyArgs),
2024 },
2025 HoleKind::Label => match t.t {
2026 T::Label => Ok(TArg::Label(self.label_use()?)),
2027 T::Hole { splice: false, .. } => {
2028 let _ = self.bump();
2029 let h = self.hole(t, HoleKind::Label)?;
2030 Ok(TArg::Label(LabelRef::Hole(LabelHole(h))))
2031 }
2032 _ => err(t.s, t.e, SyntaxError::ApplyArgs),
2033 },
2034 }
2035 }
2036
2037 fn pat(&mut self) -> R<TPat> {
2040 self.enter()?;
2041 let p = self.pat_inner();
2042 self.leave();
2043 p
2044 }
2045
2046 fn pat_inner(&mut self) -> R<TPat> {
2047 let t = self.peek();
2048 match t.t {
2049 T::Int(v) => {
2050 let _ = self.bump();
2051 Ok(self.b.lit_pat(TLit::Int(v)))
2052 }
2053 T::Float(v) => {
2054 let _ = self.bump();
2055 Ok(self.b.lit_pat(TLit::Float(v)))
2056 }
2057 T::Char(c) => {
2058 let _ = self.bump();
2059 Ok(self.b.lit_pat(TLit::Char(c)))
2060 }
2061 T::Str(_) => err(
2062 t.s,
2063 t.e,
2064 SyntaxError::Unsupported("string literal patterns"),
2065 ),
2066 T::Hole { splice: true, .. } => err(t.s, t.e, SyntaxError::SpliceHere),
2067 T::Hole { .. } => {
2068 let _ = self.bump();
2069 let h = self.hole(t, HoleKind::Pat)?;
2070 Ok(self.b.pat(PatHole(h)))
2071 }
2072 T::P(b'(') => {
2073 let _ = self.bump();
2074 let (elems, trailing) = self.pats(b')')?;
2075 if let ([only], false) = (elems.as_slice(), trailing) {
2076 return Ok(*only);
2077 }
2078 Ok(self.b.tuple_pat(&elems))
2079 }
2080 T::Free(Free::Global) => {
2081 let _ = self.bump();
2082 let path = self.word(t).split_once(':').map_or("", |(_, p)| p);
2083 check_path(path, t)?;
2084 let elems = if self.eat_p(b'(') {
2085 self.pats(b')')?.0
2086 } else {
2087 Vec::new()
2088 };
2089 Ok(self.b.ctor_pat(path, &elems))
2090 }
2091 T::Ident => self.word_pat(t),
2092 _ => err(t.s, t.e, SyntaxError::Expected("a pattern")),
2093 }
2094 }
2095
2096 fn word_pat(&mut self, t: Tok) -> R<TPat> {
2097 let word = self.word(t);
2098 match word {
2099 "_" => {
2100 let _ = self.bump();
2101 Ok(self.b.wild())
2102 }
2103 "true" | "false" => {
2104 let _ = self.bump();
2105 Ok(self.b.lit_pat(TLit::Bool(word == "true")))
2106 }
2107 "null" => {
2108 let _ = self.bump();
2109 Ok(self.b.lit_pat(TLit::Null))
2110 }
2111 "mut" => {
2112 let _ = self.bump();
2113 let (name, nt) = self.binder_name()?;
2114 let b = self.b.mutable_binder(name);
2115 self.pending.push((name, b, nt.s, nt.e));
2116 Ok(self.b.bind(b))
2117 }
2118 _ if reserved(word) => err(t.s, t.e, SyntaxError::Expected("a pattern")),
2119 _ => {
2120 let path_follows =
2121 self.peek_at(1).t == T::P(b':') && self.peek_at(2).t == T::P(b':');
2122 if path_follows || self.peek_at(1).t == T::P(b'(') {
2123 let path = self.path_text()?;
2124 let elems = if self.eat_p(b'(') {
2125 self.pats(b')')?.0
2126 } else {
2127 Vec::new()
2128 };
2129 return Ok(self.b.ctor_pat(&path, &elems));
2130 }
2131 let _ = self.bump();
2132 let b = self.b.binder(word);
2133 self.pending.push((word, b, t.s, t.e));
2134 Ok(self.b.bind(b))
2135 }
2136 }
2137 }
2138
2139 fn pats(&mut self, close: u8) -> R<(Vec<TPat>, bool)> {
2142 let mut out = Vec::new();
2143 let mut trailing = false;
2144 loop {
2145 if self.eat_p(close) {
2146 return Ok((out, trailing));
2147 }
2148 out.push(self.pat()?);
2149 trailing = self.eat_p(b',');
2150 if !trailing && !self.is_p(close) {
2151 let n = self.peek();
2152 return err(n.s, n.e, SyntaxError::Expected("`,` or a closing bracket"));
2153 }
2154 }
2155 }
2156
2157 fn path_text(&mut self) -> R<String> {
2159 let mut out = String::new();
2160 loop {
2161 let t = self.peek();
2162 if t.t != T::Ident {
2163 return err(t.s, t.e, SyntaxError::Expected("a path segment"));
2164 }
2165 let _ = self.bump();
2166 out.push_str(self.word(t));
2167 if self.is_p(b':') && self.peek_at(1).t == T::P(b':') {
2168 let _ = self.bump();
2169 let _ = self.bump();
2170 out.push_str("::");
2171 } else {
2172 return Ok(out);
2173 }
2174 }
2175 }
2176
2177 fn ty(&mut self) -> R<TTy> {
2180 self.enter()?;
2181 let t = self.ty_inner();
2182 self.leave();
2183 t
2184 }
2185
2186 fn ty_inner(&mut self) -> R<TTy> {
2187 let first = self.ty_atom()?;
2188 let sep = match self.peek().t {
2189 T::P(c @ (b'|' | b'&')) => c,
2190 _ => return Ok(first),
2191 };
2192 let mut members = alloc::vec![first];
2193 while self.eat_p(sep) {
2194 members.push(self.ty_atom()?);
2195 }
2196 let t = self.peek();
2197 if let T::P(b'|' | b'&') = t.t {
2198 return err(
2199 t.s,
2200 t.e,
2201 SyntaxError::Expected("parentheses around a union inside an intersection"),
2202 );
2203 }
2204 Ok(if sep == b'|' {
2205 self.b.union_ty(&members)
2206 } else {
2207 self.b.intersection_ty(&members)
2208 })
2209 }
2210
2211 fn ty_atom(&mut self) -> R<TTy> {
2212 let t = self.peek();
2213 match t.t {
2214 T::Hole { splice: true, .. } => err(t.s, t.e, SyntaxError::SpliceHere),
2215 T::Hole { .. } => {
2216 let _ = self.bump();
2217 let h = self.hole(t, HoleKind::Ty)?;
2218 Ok(self.b.ty(TyHole(h)))
2219 }
2220 T::Free(Free::Global) => {
2221 let _ = self.bump();
2222 let path = self.word(t).split_once(':').map_or("", |(_, p)| p);
2223 check_path(path, t)?;
2224 Ok(self.b.named_ty(path))
2225 }
2226 T::P(b'(') => {
2227 let _ = self.bump();
2228 let inner = self.ty()?;
2229 let _ = self.expect_p(b')', "`)`")?;
2230 Ok(inner)
2231 }
2232 T::Ident => {
2233 let word = self.word(t);
2234 if word == "_" {
2235 let _ = self.bump();
2236 return Ok(self.b.infer_ty());
2237 }
2238 if word == "any" {
2239 let _ = self.bump();
2240 return Ok(self.b.any_ty());
2241 }
2242 if let Some(p) = prim_named(word) {
2243 let _ = self.bump();
2244 return Ok(self.b.prim(p));
2245 }
2246 if reserved(word) {
2247 return err(t.s, t.e, SyntaxError::Expected("a type"));
2248 }
2249 let path = self.path_text()?;
2250 Ok(self.b.named_ty(&path))
2251 }
2252 _ => err(t.s, t.e, SyntaxError::Expected("a type")),
2253 }
2254 }
2255}
2256
2257fn set_policy(policy: &mut hir_lang::Policy, key: &str, value: &str) -> bool {
2260 match key {
2261 "overflow" if policy.overflow.is_none() => {
2262 policy.overflow = match value {
2263 "error" => Some(Overflow::Error),
2264 "wrap" => Some(Overflow::Wrap),
2265 "trap" => Some(Overflow::Trap),
2266 "promote" => Some(Overflow::Promote),
2267 _ => return false,
2268 };
2269 }
2270 "div_zero" if policy.div_zero.is_none() => {
2271 policy.div_zero = match value {
2272 "error" => Some(DivZero::Error),
2273 "trap" => Some(DivZero::Trap),
2274 _ => return false,
2275 };
2276 }
2277 "shift" if policy.shift.is_none() => {
2278 policy.shift = match value {
2279 "error" => Some(Shift::Error),
2280 "mask" => Some(Shift::Mask),
2281 "saturate" => Some(Shift::Saturate),
2282 _ => return false,
2283 };
2284 }
2285 "float_to_int" if policy.float_to_int.is_none() => {
2286 policy.float_to_int = match value {
2287 "error" => Some(FloatToInt::Error),
2288 "saturate" => Some(FloatToInt::Saturate),
2289 _ => return false,
2290 };
2291 }
2292 _ => return false,
2293 }
2294 true
2295}
2296
2297fn check_path(path: &str, t: Tok) -> R<()> {
2299 let ok = !path.is_empty()
2300 && path.split("::").all(|seg| {
2301 let mut bytes = seg.bytes();
2302 bytes.next().is_some_and(ident_start) && bytes.all(ident_char)
2303 });
2304 if ok {
2305 Ok(())
2306 } else {
2307 err(t.s, t.e, SyntaxError::Expected("a path like `a::b`"))
2308 }
2309}
2310
2311#[cfg(test)]
2312mod tests;