Skip to main content

lower_lang/
text.rs

1//! Textual templates: the template subset of HIR's textual syntax (HIR spec
2//! §20 "Template additions", LSF2 §15.7/§15.8), parsed straight into the
3//! [`Template`] AST that [`TemplateBuilder`] builds.
4//!
5//! The text is parsed once, at forge time, into builder calls. Nothing is
6//! ever substituted as text: holes are filled with already-lowered HIR when
7//! the template is instantiated, so a template cannot produce text that
8//! re-lexes differently (decision D26).
9//!
10//! The parser is recursive descent with an explicit nesting cap
11//! ([`MAX_TEMPLATE_DEPTH`]) and a length cap ([`MAX_TEMPLATE_TEXT`]); every
12//! lookup (holes, binders, labels, templates) is a sorted-map lookup, so
13//! parsing is `O(n log n)` in the text and never quadratic. It never panics:
14//! every refusal is a [`TemplateError::Syntax`] with the byte range of the
15//! offending text.
16
17use 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
29/// The longest template text [`Template::parse`] accepts, in bytes (1 MiB).
30/// Longer texts are refused with [`SyntaxError::TooLong`].
31///
32/// # Examples
33///
34/// ```
35/// use lower_lang::{SyntaxError, Template, TemplateError, MAX_TEMPLATE_TEXT};
36///
37/// let long = " ".repeat(MAX_TEMPLATE_TEXT + 1);
38/// assert!(matches!(
39///     Template::parse("t", &long),
40///     Err(TemplateError::Syntax { error: SyntaxError::TooLong, .. })
41/// ));
42/// ```
43pub const MAX_TEMPLATE_TEXT: usize = 1 << 20;
44
45/// The deepest nesting [`Template::parse`] accepts: expressions, blocks,
46/// patterns, and types inside one another (Mox's largest template,
47/// `yield_from`, nests 10 deep). Deeper text is refused with
48/// [`SyntaxError::TooDeep`] instead of exhausting the stack: at the cap the
49/// parser needs under 256 KiB of stack in an unoptimized build and under
50/// 64 KiB optimized.
51///
52/// # Examples
53///
54/// ```
55/// use lower_lang::{SyntaxError, Template, TemplateError, MAX_TEMPLATE_DEPTH};
56///
57/// let deep = "(".repeat(MAX_TEMPLATE_DEPTH as usize + 1);
58/// assert!(matches!(
59///     Template::parse("t", &deep),
60///     Err(TemplateError::Syntax { error: SyntaxError::TooDeep, .. })
61/// ));
62/// ```
63pub const MAX_TEMPLATE_DEPTH: u32 = 32;
64
65/// What is wrong with a template text. Carried by
66/// [`TemplateError::Syntax`] together with the byte range it is about.
67///
68/// # Examples
69///
70/// ```
71/// use lower_lang::{SyntaxError, Template, TemplateError};
72///
73/// let err = Template::parse("t", "add(1)").unwrap_err();
74/// let TemplateError::Syntax { at, error } = err else { unreachable!() };
75/// assert_eq!(error, SyntaxError::Arity { expected: 2, found: 1 });
76/// assert_eq!((at.start().to_usize(), at.end().to_usize()), (0, 3));
77/// ```
78#[derive(Clone, Copy, Debug, PartialEq, Eq)]
79#[non_exhaustive]
80pub enum SyntaxError {
81    /// The text is longer than [`MAX_TEMPLATE_TEXT`]. Split the template, or
82    /// build it with [`TemplateBuilder`].
83    TooLong,
84    /// Nesting is deeper than [`MAX_TEMPLATE_DEPTH`]. Flatten the template
85    /// (name intermediate values with `let`).
86    TooDeep,
87    /// A character that starts no token (templates are ASCII outside string
88    /// literals).
89    UnexpectedChar,
90    /// A string, character literal, or hole that is not closed.
91    Unterminated,
92    /// An unknown escape sequence in a string or character literal.
93    BadEscape,
94    /// A malformed number, or one that does not fit `i64` / a finite `f64`.
95    BadNumber,
96    /// Something else was expected here; the payload says what.
97    Expected(&'static str),
98    /// A name that is neither a binder in scope nor an operation. Free names
99    /// are written `global:name`, host symbols `extern:name`.
100    UnknownName,
101    /// A binder written with an id (`x%0`): template binders are written
102    /// without one and are fresh per instantiation.
103    BinderId,
104    /// An operation name that OPS does not define, or a conversion without
105    /// its target type (`int_cast<i32>(x)`).
106    UnknownOp,
107    /// A policy the operation does not consult, an unknown policy value, a
108    /// repeated policy, or a target type on an operation that takes none.
109    BadPolicy,
110    /// An operation with the wrong number of operands.
111    Arity {
112        /// The operation's arity.
113        expected: usize,
114        /// The operands written.
115        found: usize,
116    },
117    /// A hole used in positions of two different kinds (`${x}` as an
118    /// expression and as a pattern).
119    HoleKind {
120        /// The kind of its first use.
121        first: HoleKind,
122        /// The kind of this use.
123        here: HoleKind,
124    },
125    /// Two uses of a hole give it different `?` / `?=default` suffixes.
126    HoleSuffix,
127    /// A default on a hole that cannot have one (only expression holes take
128    /// `?=<literal>`), or a default that is not a literal.
129    HoleDefault,
130    /// An argument splice `${...name}` outside a call's arguments, a tuple's
131    /// or array's elements, or a block's statements.
132    SpliceHere,
133    /// One pattern (or one closure's parameters) binds the same name twice.
134    BoundTwice,
135    /// A label that no enclosing loop or block of the template defines.
136    UnknownLabel,
137    /// `apply:<name>` names no template registered before this one.
138    UnknownTemplate,
139    /// `apply:<name>(...)` arguments do not fit the applied template's holes
140    /// (too many, a required one missing, or the wrong kind).
141    ApplyArgs,
142    /// A construct the template subset does not have; the payload names it.
143    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// ---------------------------------------------------------------- tokens
193
194/// A hole's suffix: nothing, `?`, or `?=<literal>`.
195#[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    /// A string literal: its decoded text is `strs[i]`.
215    Str(u32),
216    Char(char),
217    /// `'name`; the name is the token text after the quote.
218    Label,
219    /// `${name}`, `${name?}`, `${name?=lit}`, `${...name}`; the name is
220    /// `text[name.0..name.1]`.
221    Hole {
222        splice: bool,
223        name: (u32, u32),
224        suffix: Suffix,
225    },
226    /// `extern:`, `global:`, `apply:`; the path is the token text after the
227    /// colon.
228    Free(Free),
229    /// One punctuation byte: `{ } ( ) [ ] , ; = : < > | & . -`.
230    P(u8),
231    /// `=>`.
232    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
260/// Splits the text into tokens and decodes its string literals.
261struct 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    /// Byte offsets fit `u32`: the text is at most [`MAX_TEMPLATE_TEXT`].
291    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            // `extern:mox.iter`, `global:a::b`, `apply:name`.
354            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    /// The literal of `${name?=<literal>}`, lexed by the template lexer.
427    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            // `12abc`: a suffix or a typo; neither is a template literal.
524            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    /// One character after a backslash, at `self.i` (just past the `\`).
572    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    /// `'a'` (a character) or `'name` (a label).
649    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// ---------------------------------------------------------------- tables
700
701/// An operation name: a plain op, or a conversion that needs its target.
702#[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
781/// Words that are never binder names.
782fn 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
810/// The LSF2 names of lower-lang's built-in templates (LSF2 §15.7) and the
811/// names they are registered under, for `apply:<name>`.
812const 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/// The templates `apply:<name>` can name: those registered in a mapping
827/// before the one being parsed, by name (the latest registration of a name
828/// wins).
829#[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            // Only the built-in itself answers to its LSF2 name.
845            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// ---------------------------------------------------------------- parser
855
856#[derive(Clone, Copy)]
857struct HoleInfo {
858    index: u16,
859    kind: HoleKind,
860    /// Whether a use has written a `?` / `?=` suffix yet.
861    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    /// Binders a pattern under construction introduces, not yet in scope.
877    pending: Vec<(&'a str, TBinder, u32, u32)>,
878    depth: u32,
879    registry: Option<Registry<'a>>,
880}
881
882/// Parses `text` as template `name`, `apply:` resolving against `registry`.
883pub(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    // ------------------------------------------------------------ tokens
922
923    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    /// The token just consumed.
997    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    /// One more level of nesting, refused past [`MAX_TEMPLATE_DEPTH`].
1005    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    /// Whether the next token can start an expression (for the optional
1019    /// operands of `return`, `break`, and `yield`).
1020    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    // ------------------------------------------------------------- scopes
1037
1038    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    /// Moves the binders pending since `from` into scope, refusing a name
1065    /// bound twice among them.
1066    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    /// A binder name: an identifier that is not reserved.
1085    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    // -------------------------------------------------------------- holes
1096
1097    /// The hole a hole token names, declared on first use with `kind`.
1098    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    /// A later use's suffix makes an expression, pattern, or type hole
1154    /// optional (holes of the other kinds always are).
1155    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    // -------------------------------------------------------- expressions
1186
1187    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    /// `'name` used as a jump target.
1289    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    /// `let_place p = place in body`.
1299    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    /// Comma-separated expressions up to `close` (consumed); `${...name}`
1348    /// splices an argument-list hole.
1349    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    /// `(e)`, `()`, `(a,)`, `(a, b)`.
1466    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    /// `'name loop { … }` or `'name { … }`.
1486    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    /// Whether the next tokens start a block-like expression, which ends a
1526    /// statement without a `;`.
1527    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            // Every block-like form enters a nesting level of its own.
1583            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    /// A block-like expression in statement position: no postfix and no
1602    /// assignment follows it.
1603    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    /// `let pat (: ty)? (= init)?;` — the pattern's names are in scope after
1622    /// the statement.
1623    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            // A block-bodied arm needs no comma.
1704            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    /// `loop ([step: e])? { … }`, its label already parsed.
1729    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    /// `closure[mode](a, mut b) => body`; the mode is `none` (the default),
1749    /// `infer`, `by-ref`, `by-mut-ref`, or `by-value`.
1750    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(&params, body?, mode))
1825    }
1826
1827    /// `name(args)` or `name<policy, …>(args)`.
1828    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        // Exact: the written fields, OPS defaults for the rest; a field the
1919        // op does not consult is refused.
1920        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    /// `apply:name(args)`: one argument per hole of the applied template, of
1941    /// that hole's kind; trailing optional holes may be left out and `_`
1942    /// leaves an optional hole absent.
1943    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                // Its names are in scope for the remaining arguments.
2007                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    // ----------------------------------------------------------- patterns
2038
2039    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    /// Patterns up to `close` (consumed), and whether a trailing comma was
2140    /// written (`(p,)` is a one-tuple).
2141    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    /// `a::b::c` as written, from identifiers separated by `::`.
2158    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    // -------------------------------------------------------------- types
2178
2179    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
2257/// Sets one policy field from its written name and value; `false` for an
2258/// unknown name or value, or a field written twice.
2259fn 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
2297/// A `global:` path: identifiers separated by `::`.
2298fn 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;