Skip to main content

dive_pluscal/
parser.rs

1//! Recursive descent for original C/P source grammar; bounded statement arena.
2use crate::{
3    Code, Diagnostic, Parsed,
4    ast::{
5        Algorithm, Assignment, Binding, BindingKind, Block, Body, Branch, Decl, Expr, Fairness,
6        Label, Macro, Name, Procedure, Process, Span, Statement, StatementKind, StmtId, Syntax,
7        Token, WithBinding,
8    },
9    lexer,
10};
11use serde::{Deserialize, Serialize};
12
13/// Source language and resource settings. Hard byte/depth ceilings bound allocation.
14#[derive(Clone, Debug, Serialize, Deserialize)]
15pub struct Options {
16    /// Input language weight in decimal thousandths (default 1903).
17    /// Exactly 1500 enables the historical sequential `fair` spelling.
18    #[serde(default = "current_version")]
19    pub input_version: i32,
20    /// Maximum complete source bytes (hard ceiling: 4 MiB).
21    pub max_bytes: usize,
22    /// Maximum significant tokens (also bounded by bytes).
23    pub max_tokens: usize,
24    /// Maximum statement/declaration/branch nodes.
25    pub max_nodes: usize,
26    /// Maximum grammar and expression nesting (hard ceiling: 256).
27    pub max_depth: usize,
28}
29const fn current_version() -> i32 {
30    1903
31}
32impl Default for Options {
33    fn default() -> Self {
34        Self {
35            input_version: current_version(),
36            max_bytes: 1_048_576,
37            max_tokens: 100_000,
38            max_nodes: 50_000,
39            max_depth: 128,
40        }
41    }
42}
43
44/// Parses a complete standalone algorithm source, rejecting trailing tokens.
45/// This certifies source grammar only; translation remains explicitly pending.
46///
47/// # Errors
48/// A lexical, grammar or resource diagnostic with an original source span.
49pub fn parse(source: &str, opts: &Options) -> Result<Parsed, Diagnostic> {
50    parse_at(source, 0..source.len(), opts)
51}
52
53/// Parses an explicitly selected algorithm region in a surrounding source file.
54/// The region must include the `--algorithm`/`--fair` marker and exclude enclosing
55/// comment delimiters and unrelated TLA+ text. Every selected token is consumed.
56/// Returned spans refer to the complete original source, not the selected slice.
57/// Parsing runs on a scoped worker with a 16 MiB stack, so the hard recursive
58/// depth ceiling does not depend on the caller's stack size. The worker is
59/// joined before returning and never outlives the borrowed input.
60///
61/// # Errors
62/// Invalid region boundaries or lexical/grammar/resource diagnostics.
63pub fn parse_at(
64    source: &str,
65    region: std::ops::Range<usize>,
66    opts: &Options,
67) -> Result<Parsed, Diagnostic> {
68    parse_scoped(source, region, opts, true)
69}
70
71pub(crate) fn parse_prefix_at(
72    source: &str,
73    region: std::ops::Range<usize>,
74    opts: &Options,
75) -> Result<Parsed, Diagnostic> {
76    parse_scoped(source, region, opts, false)
77}
78
79fn parse_scoped(
80    source: &str,
81    region: std::ops::Range<usize>,
82    opts: &Options,
83    complete: bool,
84) -> Result<Parsed, Diagnostic> {
85    std::thread::scope(|scope| {
86        let failure = |code, message: String| Diagnostic {
87            code,
88            span: Span::default(),
89            message,
90        };
91        let worker = std::thread::Builder::new()
92            .name("dive-pluscal-parser".into())
93            .stack_size(16 * 1024 * 1024)
94            .spawn_scoped(scope, || parse_selected(source, region, opts, complete))
95            .map_err(|error| {
96                failure(
97                    Code::Resource,
98                    format!("cannot start PlusCal parser: {error}"),
99                )
100            })?;
101        worker.join().map_err(|_| {
102            failure(
103                Code::Internal,
104                "PlusCal parser worker failed; report this input as a bug".into(),
105            )
106        })?
107    })
108}
109
110fn parse_selected(
111    source: &str,
112    region: std::ops::Range<usize>,
113    opts: &Options,
114    complete: bool,
115) -> Result<Parsed, Diagnostic> {
116    let nearest = |offset: usize| {
117        let mut offset = offset.min(source.len());
118        while !source.is_char_boundary(offset) {
119            offset -= 1;
120        }
121        offset
122    };
123    let start = nearest(region.start);
124    let span = Span {
125        start,
126        end: nearest(region.end).max(start),
127    };
128    let error = |code, message: &str| Diagnostic {
129        code,
130        span,
131        message: message.into(),
132    };
133    if source.len() > opts.max_bytes.min(4_194_304) {
134        return Err(error(Code::Resource, "PlusCal source byte limit reached"));
135    }
136    let Some(text) = source.get(region.clone()) else {
137        return Err(error(Code::Syntax, "invalid PlusCal source region"));
138    };
139    let trimmed = text.trim_start();
140    let begin = region.start + text.len() - trimmed.len();
141    let (prefix, fair) = if trimmed.starts_with("--algorithm") {
142        ("--algorithm", false)
143    } else if trimmed.starts_with("--fair") {
144        ("--fair", true)
145    } else {
146        return Err(error(
147            Code::Syntax,
148            "expected --algorithm or --fair algorithm",
149        ));
150    };
151    let after = begin + prefix.len();
152    if source
153        .get(after..region.end)
154        .and_then(|s| s.chars().next())
155        .is_some_and(|c| c.is_alphanumeric() || c == '_')
156    {
157        return Err(error(
158            Code::Syntax,
159            "algorithm marker requires a token boundary",
160        ));
161    }
162    let (tokens, deferred) = if complete {
163        (
164            lexer::tokenize(source, after, region.end, opts.max_tokens)?,
165            Vec::new(),
166        )
167    } else {
168        lexer::tokenize_prefix(source, after, region.end, opts.max_tokens)?
169    };
170    let mut parser = Parser {
171        tokens,
172        pos: 0,
173        statements: Vec::new(),
174        syntax: Syntax::P,
175        opts,
176        nodes: 0,
177        in_macro: false,
178        end: region.end,
179    };
180    if fair {
181        parser.need("algorithm")?;
182    }
183    let algorithm = parser
184        .algorithm(begin, fair)
185        .map_err(|error| deferred.first().cloned().unwrap_or(error))?;
186    if let Some(error) = deferred
187        .into_iter()
188        .find(|error| error.span.start < algorithm.span.end)
189    {
190        return Err(error);
191    }
192    if complete && parser.pos != parser.tokens.len() {
193        return Err(parser.error(Code::Syntax, "unexpected trailing algorithm content"));
194    }
195    parser.tokens.truncate(parser.pos);
196    Ok(Parsed {
197        source: source.to_owned(),
198        algorithm,
199        statements: parser.statements,
200        tokens: parser.tokens,
201    })
202}
203
204struct Parser<'a> {
205    tokens: Vec<Token>,
206    pos: usize,
207    statements: Vec<Statement>,
208    syntax: Syntax,
209    opts: &'a Options,
210    nodes: usize,
211    in_macro: bool,
212    end: usize,
213}
214impl Parser<'_> {
215    fn peek(&self) -> &str {
216        self.tokens.get(self.pos).map_or("", |t| t.text.as_str())
217    }
218    fn at(&self, n: usize) -> &str {
219        self.tokens
220            .get(self.pos.saturating_add(n))
221            .map_or("", |t| t.text.as_str())
222    }
223    fn start(&self) -> usize {
224        self.tokens.get(self.pos).map_or(self.end, |t| t.span.start)
225    }
226    fn last(&self) -> usize {
227        self.pos
228            .checked_sub(1)
229            .and_then(|i| self.tokens.get(i))
230            .map_or(self.start(), |t| t.span.end)
231    }
232    fn error(&self, code: Code, message: &str) -> Diagnostic {
233        Diagnostic {
234            code,
235            span: self.tokens.get(self.pos).map_or(
236                Span {
237                    start: self.end,
238                    end: self.end,
239                },
240                |t| t.span,
241            ),
242            message: message.into(),
243        }
244    }
245    fn take(&mut self) -> Result<Token, Diagnostic> {
246        let token = self
247            .tokens
248            .get(self.pos)
249            .cloned()
250            .ok_or_else(|| self.error(Code::Syntax, "unexpected end of algorithm"))?;
251        self.pos += 1;
252        Ok(token)
253    }
254    fn eat(&mut self, word: &str) -> bool {
255        if self.peek() == word {
256            self.pos += 1;
257            true
258        } else {
259            false
260        }
261    }
262    fn need(&mut self, word: &str) -> Result<(), Diagnostic> {
263        if self.eat(word) {
264            Ok(())
265        } else {
266            Err(self.error(
267                Code::Syntax,
268                &format!("expected {word:?}, found {:?}", self.peek()),
269            ))
270        }
271    }
272    fn charge(&mut self, depth: usize) -> Result<(), Diagnostic> {
273        if depth > self.opts.max_depth.min(256) || self.nodes >= self.opts.max_nodes {
274            return Err(self.error(Code::Resource, "PlusCal node/nesting limit reached"));
275        }
276        self.nodes += 1;
277        Ok(())
278    }
279    fn name(&mut self) -> Result<Name, Diagnostic> {
280        let token = self.take()?;
281        // The Java grammar reads names as algorithm tokens. Preserve its
282        // spelling rather than silently applying SANY name-resolution rules.
283        if token.text.is_empty()
284            || matches!(
285                token.text.as_str(),
286                ";" | "," | "(" | ")" | "{" | "}" | ":=" | "≔"
287            )
288        {
289            return Err(Diagnostic {
290                code: Code::Syntax,
291                span: token.span,
292                message: "expected a name token".into(),
293            });
294        }
295        Ok(Name {
296            text: token.text,
297            span: token.span,
298        })
299    }
300    fn semi(&mut self) -> Result<(), Diagnostic> {
301        if self.eat(";")
302            || matches!(
303                self.peek(),
304                "end"
305                    | "begin"
306                    | "else"
307                    | "elsif"
308                    | "or"
309                    | "do"
310                    | "macro"
311                    | "procedure"
312                    | "process"
313                    | "fair"
314                    | "define"
315                    | "}"
316                    | "{"
317            )
318        {
319            Ok(())
320        } else {
321            Err(self.error(Code::Syntax, "expected statement/declaration separator ';'"))
322        }
323    }
324    fn separator(&mut self) -> Result<(), Diagnostic> {
325        if self.eat(",") { Ok(()) } else { self.semi() }
326    }
327    fn binding(&mut self) -> Result<Binding, Diagnostic> {
328        let kind = if self.eat("=") {
329            BindingKind::Equal
330        } else if self.eat("\\in") || self.eat("∈") {
331            BindingKind::Member
332        } else {
333            return Err(self.error(Code::Syntax, "expected '=' or membership binder"));
334        };
335        Ok(Binding {
336            kind,
337            expression: self.expression(false, false)?,
338        })
339    }
340    fn declaration(&mut self, parameter: bool) -> Result<Decl, Diagnostic> {
341        self.charge(0)?;
342        let name = self.name()?;
343        let start = name.span.start;
344        let initial = if matches!(self.peek(), "=" | "\\in" | "∈") {
345            if parameter && self.peek() != "=" {
346                return Err(self.error(
347                    Code::Syntax,
348                    "procedure parameter cannot use membership initialization",
349                ));
350            }
351            Some(self.binding()?)
352        } else {
353            None
354        };
355        Ok(Decl {
356            name,
357            initial,
358            span: Span {
359                start,
360                end: self.last(),
361            },
362        })
363    }
364    fn variables(&mut self, parameter: bool) -> Result<Vec<Decl>, Diagnostic> {
365        if !self.eat("variable") && !self.eat("variables") {
366            return Ok(Vec::new());
367        }
368        let mut variables = Vec::new();
369        while !matches!(
370            self.peek(),
371            "begin" | "{" | "define" | "macro" | "procedure" | "process" | "fair" | ""
372        ) {
373            variables.push(self.declaration(parameter)?);
374            self.separator()?;
375        }
376        Ok(variables)
377    }
378    fn begin(&mut self) -> Result<(), Diagnostic> {
379        self.need(if self.syntax == Syntax::P {
380            "begin"
381        } else {
382            "{"
383        })
384    }
385    fn finish(&mut self, role: &str) -> Result<(), Diagnostic> {
386        if self.syntax == Syntax::P {
387            self.need("end")?;
388            self.need(role)
389        } else {
390            self.need("}")
391        }
392    }
393    fn algorithm(&mut self, start: usize, fair: bool) -> Result<Algorithm, Diagnostic> {
394        self.charge(0)?;
395        let name = self.name()?;
396        if self.eat("{") {
397            self.syntax = Syntax::C;
398        }
399        let variables = self.variables(false)?;
400        let definitions = if self.eat("define") {
401            if self.syntax == Syntax::C {
402                self.need("{")?;
403            }
404            let expression = self.expression(true, true)?;
405            self.finish("define")?;
406            self.semi()?;
407            Some(expression)
408        } else {
409            None
410        };
411        let mut macros = Vec::new();
412        while self.peek() == "macro" {
413            macros.push(self.macro_def()?);
414        }
415        let mut procedures = Vec::new();
416        while self.peek() == "procedure" {
417            procedures.push(self.procedure()?);
418        }
419        let legacy_fair = self.opts.input_version == 1500
420            && self.peek() == "fair"
421            && self.tokens.get(self.pos + 1).is_some_and(|t| {
422                matches!(t.text.as_str(), "begin" | "{")
423                    || (t.text == "+"
424                        && self
425                            .tokens
426                            .get(self.pos + 2)
427                            .is_some_and(|next| matches!(next.text.as_str(), "begin" | "{")))
428            });
429        if legacy_fair {
430            self.eat("fair");
431            self.eat("+");
432        }
433        let body = if matches!(self.peek(), "process" | "fair") {
434            let mut processes = Vec::new();
435            while matches!(self.peek(), "process" | "fair") {
436                processes.push(self.process()?);
437            }
438            Body::Processes(processes)
439        } else {
440            self.begin()?;
441            let block = self.sequence(0, &["end", "}"], self.syntax == Syntax::C)?;
442            if self.syntax == Syntax::C {
443                self.need("}")?;
444            }
445            Body::Sequential(block)
446        };
447        self.finish("algorithm")?;
448        self.eat(";");
449        Ok(Algorithm {
450            name,
451            syntax: self.syntax,
452            fairness: if fair {
453                Fairness::Weak
454            } else {
455                Fairness::Unfair
456            },
457            legacy_fair,
458            variables,
459            definitions,
460            macros,
461            procedures,
462            body,
463            span: Span {
464                start,
465                end: self.last(),
466            },
467        })
468    }
469    fn macro_def(&mut self) -> Result<Macro, Diagnostic> {
470        self.charge(0)?;
471        let start = self.start();
472        self.need("macro")?;
473        let name = self.name()?;
474        self.need("(")?;
475        let mut parameters = Vec::new();
476        while self.peek() != ")" {
477            parameters.push(self.name()?);
478            if self.peek() != ")" {
479                self.need(",")?;
480            }
481        }
482        self.need(")")?;
483        self.begin()?;
484        self.in_macro = true;
485        let body = self.sequence(0, &["end", "}"], self.syntax == Syntax::C)?;
486        self.in_macro = false;
487        self.finish("macro")?;
488        self.eat(";");
489        Ok(Macro {
490            name,
491            parameters,
492            body,
493            span: Span {
494                start,
495                end: self.last(),
496            },
497        })
498    }
499    fn procedure(&mut self) -> Result<Procedure, Diagnostic> {
500        self.charge(0)?;
501        let start = self.start();
502        self.need("procedure")?;
503        let name = self.name()?;
504        self.need("(")?;
505        let mut parameters = Vec::new();
506        while self.peek() != ")" {
507            parameters.push(self.declaration(true)?);
508            if self.peek() != ")" {
509                self.need(",")?;
510            }
511        }
512        self.need(")")?;
513        let variables = self.variables(true)?;
514        self.begin()?;
515        let body = self.sequence(0, &["end", "}"], self.syntax == Syntax::C)?;
516        self.finish("procedure")?;
517        self.eat(";");
518        Ok(Procedure {
519            name,
520            parameters,
521            variables,
522            body,
523            span: Span {
524                start,
525                end: self.last(),
526            },
527        })
528    }
529    fn process(&mut self) -> Result<Process, Diagnostic> {
530        self.charge(0)?;
531        let start = self.start();
532        let fairness = if self.eat("fair") {
533            if self.eat("+") {
534                Fairness::Strong
535            } else {
536                Fairness::Weak
537            }
538        } else {
539            Fairness::Unfair
540        };
541        self.need("process")?;
542        if self.syntax == Syntax::C {
543            self.need("(")?;
544        }
545        let name = self.name()?;
546        let id = self.binding()?;
547        if self.syntax == Syntax::C {
548            self.need(")")?;
549        }
550        let variables = self.variables(false)?;
551        self.begin()?;
552        let body = self.sequence(0, &["end", "}"], self.syntax == Syntax::C)?;
553        self.finish("process")?;
554        self.eat(";");
555        Ok(Process {
556            name,
557            fairness,
558            id,
559            variables,
560            body,
561            span: Span {
562                start,
563                end: self.last(),
564            },
565        })
566    }
567
568    fn expression(&mut self, define: bool, empty: bool) -> Result<Expr, Diagnostic> {
569        let start = self.start();
570        let first = self.pos;
571        let mut depth = 0usize;
572        let mut quantifier = false;
573        let mut previous = " ".to_owned();
574        while !self.peek().is_empty() {
575            let word = self.peek();
576            let field = matches!(previous.as_str(), "." | "[" | ",")
577                && word
578                    .chars()
579                    .next()
580                    .is_some_and(|c| c.is_alphabetic() || c == '_');
581            let delimiter = matches!(
582                word,
583                ";" | "do"
584                    | "then"
585                    | ":="
586                    | "≔"
587                    | "begin"
588                    | "variable"
589                    | "variables"
590                    | "||"
591                    | "‖"
592                    | "end"
593                    | "else"
594                    | "elsif"
595                    | "if"
596                    | "either"
597                    | "or"
598                    | "while"
599                    | "with"
600                    | "call"
601                    | "return"
602                    | "goto"
603                    | "print"
604                    | "assert"
605                    | "skip"
606                    | "procedure"
607                    | "define"
608                    | "process"
609                    | "fair"
610            ) && !field;
611            if delimiter
612                || (depth == 0 && matches!(word, ")" | "}"))
613                || (depth == 0 && word == "," && !quantifier && !define)
614            {
615                if depth != 0 || quantifier {
616                    return Err(self.error(
617                        Code::Expression,
618                        "expression has unmatched nesting or a quantifier without ':'",
619                    ));
620                }
621                break;
622            }
623            if matches!(word, "(" | "[" | "{" | "<<" | "⟨") {
624                depth += 1;
625                if depth > self.opts.max_depth.min(256) {
626                    return Err(
627                        self.error(Code::Resource, "PlusCal expression nesting limit reached")
628                    );
629                }
630            } else if matches!(word, ")" | "]" | "}" | ">>" | "⟩" | "]_" | ">>_" | "⟩_") {
631                depth = depth.checked_sub(1).ok_or_else(|| {
632                    self.error(Code::Expression, "extra closing expression delimiter")
633                })?;
634            }
635            if depth == 0 && matches!(word, "\\A" | "∀" | "\\E" | "∃") {
636                quantifier = true;
637            }
638            if depth == 0 && word == ":" {
639                quantifier = false;
640            }
641            previous = if word.starts_with('"') {
642                " ".into()
643            } else {
644                word.to_owned()
645            };
646            self.pos += 1;
647        }
648        if depth != 0 || quantifier {
649            return Err(self.error(
650                Code::Expression,
651                "unterminated expression nesting or quantifier",
652            ));
653        }
654        if self.pos == first && !empty {
655            return Err(self.error(Code::Expression, "missing expression"));
656        }
657        Ok(Expr {
658            span: Span {
659                start,
660                end: if self.pos == first {
661                    start
662                } else {
663                    self.last()
664                },
665            },
666        })
667    }
668    fn label(&mut self) -> Result<Option<Label>, Diagnostic> {
669        if self.at(1) != ":"
670            || matches!(
671                self.peek(),
672                "while"
673                    | "if"
674                    | "else"
675                    | "elsif"
676                    | "either"
677                    | "or"
678                    | "end"
679                    | "with"
680                    | "when"
681                    | "await"
682                    | "skip"
683                    | "call"
684                    | "return"
685                    | "goto"
686                    | "assert"
687                    | "print"
688            )
689        {
690            return Ok(None);
691        }
692        let name = self.name()?;
693        if self.in_macro || matches!(name.text.as_str(), "Done" | "Error") {
694            return Err(Diagnostic {
695                code: Code::Label,
696                span: name.span,
697                message: "reserved label or label inside a macro".into(),
698            });
699        }
700        self.need(":")?;
701        let modifier = if self.eat("+") {
702            Some('+')
703        } else if self.eat("-") {
704            Some('-')
705        } else {
706            None
707        };
708        let span = Span {
709            start: name.span.start,
710            end: self.last(),
711        };
712        Ok(Some(Label {
713            name,
714            modifier,
715            span,
716        }))
717    }
718    fn sequence(
719        &mut self,
720        depth: usize,
721        stops: &[&str],
722        nonempty: bool,
723    ) -> Result<Block, Diagnostic> {
724        let start = self.start();
725        let mut statements = Vec::new();
726        while !self.peek().is_empty() && !stops.contains(&self.peek()) {
727            statements.push(self.statement(depth + 1)?);
728        }
729        if nonempty && statements.is_empty() {
730            return Err(self.error(Code::Syntax, "empty statement body"));
731        }
732        let end = if statements.is_empty() {
733            start
734        } else {
735            self.last()
736        };
737        Ok(Block {
738            span: Span { start, end },
739            statements,
740        })
741    }
742    fn c_body(&mut self, depth: usize) -> Result<Block, Diagnostic> {
743        let start = self.start();
744        let id = self.statement(depth + 1)?;
745        Ok(Block {
746            span: Span {
747                start,
748                end: self.last(),
749            },
750            statements: vec![id],
751        })
752    }
753    fn arguments(&mut self) -> Result<Vec<Expr>, Diagnostic> {
754        self.need("(")?;
755        let mut args = Vec::new();
756        while self.peek() != ")" {
757            args.push(self.expression(false, false)?);
758            if self.peek() != ")" {
759                self.need(",")?;
760            }
761        }
762        self.need(")")?;
763        Ok(args)
764    }
765    fn assignment(&mut self) -> Result<Assignment, Diagnostic> {
766        self.charge(0)?;
767        let variable = self.name()?;
768        let start = variable.span.start;
769        let selectors = self.expression(false, true)?;
770        if !self.eat(":=") && !self.eat("≔") {
771            return Err(self.error(Code::Syntax, "expected ':=' assignment token"));
772        }
773        let value = self.expression(false, false)?;
774        Ok(Assignment {
775            variable,
776            selectors: if selectors.span.start == selectors.span.end {
777                None
778            } else {
779                Some(selectors)
780            },
781            value,
782            span: Span {
783                start,
784                end: self.last(),
785            },
786        })
787    }
788    // Keep the complete source-grammar dispatch together; each arm preserves a
789    // distinct statement variant and recursively charges the common bounds.
790    #[allow(clippy::too_many_lines)]
791    fn statement(&mut self, depth: usize) -> Result<StmtId, Diagnostic> {
792        self.charge(depth)?;
793        let start = self.start();
794        let label = self.label()?;
795        let kind = match self.peek() {
796            "{" if self.syntax == Syntax::C => {
797                self.need("{")?;
798                let mut body = self.sequence(depth, &["}"], true)?;
799                self.need("}")?;
800                self.semi()?;
801                body.span = Span {
802                    start,
803                    end: self.last(),
804                };
805                if label.is_some()
806                    && body
807                        .statements
808                        .first()
809                        .and_then(|i| self.statements.get(i.0))
810                        .is_some_and(|s| s.label.is_some())
811                {
812                    return Err(self.error(Code::Label, "duplicate labeling of statement block"));
813                }
814                StatementKind::Block(body)
815            }
816            "while" => {
817                self.need("while")?;
818                if self.syntax == Syntax::C {
819                    self.need("(")?;
820                }
821                let test = self.expression(false, false)?;
822                let body = if self.syntax == Syntax::P {
823                    self.need("do")?;
824                    let body = self.sequence(depth, &["end"], true)?;
825                    self.finish("while")?;
826                    self.semi()?;
827                    body
828                } else {
829                    self.need(")")?;
830                    self.c_body(depth)?
831                };
832                StatementKind::While { test, body }
833            }
834            "if" => {
835                self.need("if")?;
836                let mut branches = Vec::new();
837                loop {
838                    self.charge(depth)?;
839                    if self.syntax == Syntax::C {
840                        self.need("(")?;
841                    }
842                    let test = self.expression(false, false)?;
843                    let body = if self.syntax == Syntax::P {
844                        self.need("then")?;
845                        self.sequence(depth, &["else", "elsif", "end"], false)?
846                    } else {
847                        self.need(")")?;
848                        self.c_body(depth)?
849                    };
850                    branches.push(Branch { test, body });
851                    if self.syntax == Syntax::P && self.eat("elsif") {
852                        continue;
853                    }
854                    break;
855                }
856                let otherwise = if self.eat("else") {
857                    Some(if self.syntax == Syntax::P {
858                        self.sequence(depth, &["end"], false)?
859                    } else {
860                        self.c_body(depth)?
861                    })
862                } else {
863                    None
864                };
865                if branches
866                    .last()
867                    .is_none_or(|branch| branch.body.statements.is_empty())
868                    && otherwise
869                        .as_ref()
870                        .is_none_or(|body| body.statements.is_empty())
871                {
872                    return Err(self.error(Code::Syntax, "if statement has no branch statements"));
873                }
874                if self.syntax == Syntax::P {
875                    self.finish("if")?;
876                    self.semi()?;
877                }
878                StatementKind::If {
879                    branches,
880                    otherwise,
881                }
882            }
883            "either" => {
884                self.need("either")?;
885                let mut branches = Vec::new();
886                loop {
887                    self.charge(depth)?;
888                    branches.push(if self.syntax == Syntax::P {
889                        self.sequence(depth, &["or", "end"], true)?
890                    } else {
891                        self.c_body(depth)?
892                    });
893                    if !self.eat("or") {
894                        break;
895                    }
896                }
897                if branches.len() < 2 {
898                    return Err(self.error(Code::Syntax, "either requires an or clause"));
899                }
900                if self.syntax == Syntax::P {
901                    self.finish("either")?;
902                    self.semi()?;
903                }
904                StatementKind::Either(branches)
905            }
906            "with" => {
907                self.need("with")?;
908                if self.syntax == Syntax::C {
909                    self.need("(")?;
910                }
911                let mut bindings = Vec::new();
912                loop {
913                    self.charge(depth)?;
914                    let name = self.name()?;
915                    let binding = self.binding()?;
916                    bindings.push(WithBinding { name, binding });
917                    if self.syntax == Syntax::C && self.peek() == ")" {
918                        break;
919                    }
920                    self.separator()?;
921                    if (self.syntax == Syntax::P && self.peek() == "do")
922                        || (self.syntax == Syntax::C && self.peek() == ")")
923                    {
924                        break;
925                    }
926                }
927                let body = if self.syntax == Syntax::P {
928                    self.need("do")?;
929                    let body = self.sequence(depth, &["end"], true)?;
930                    self.finish("with")?;
931                    self.semi()?;
932                    body
933                } else {
934                    self.need(")")?;
935                    self.c_body(depth)?
936                };
937                StatementKind::With { bindings, body }
938            }
939            "when" | "await" => {
940                let when = self.eat("when");
941                if !when {
942                    self.need("await")?;
943                }
944                let condition = self.expression(false, false)?;
945                self.semi()?;
946                StatementKind::Await { when, condition }
947            }
948            "assert" => {
949                self.need("assert")?;
950                let e = self.expression(false, false)?;
951                self.semi()?;
952                StatementKind::Assert(e)
953            }
954            "print" => {
955                self.need("print")?;
956                let e = self.expression(false, false)?;
957                self.semi()?;
958                StatementKind::Print(e)
959            }
960            "skip" => {
961                self.need("skip")?;
962                self.semi()?;
963                StatementKind::Skip
964            }
965            "return" => {
966                self.need("return")?;
967                self.semi()?;
968                StatementKind::Return
969            }
970            "goto" => {
971                self.need("goto")?;
972                let name = self.name()?;
973                self.semi()?;
974                StatementKind::Goto(name)
975            }
976            "call" => {
977                self.need("call")?;
978                let name = self.name()?;
979                let arguments = self.arguments()?;
980                self.semi()?;
981                StatementKind::Call { name, arguments }
982            }
983            _ if self.at(1) == "(" => {
984                let name = self.name()?;
985                let arguments = self.arguments()?;
986                self.semi()?;
987                StatementKind::MacroCall { name, arguments }
988            }
989            _ => {
990                let mut assignments = vec![self.assignment()?];
991                while self.eat("||") || self.eat("‖") {
992                    assignments.push(self.assignment()?);
993                }
994                self.semi()?;
995                StatementKind::Assign(assignments)
996            }
997        };
998        let id = StmtId(self.statements.len());
999        self.statements.push(Statement {
1000            span: Span {
1001                start,
1002                end: self.last(),
1003            },
1004            label,
1005            kind,
1006        });
1007        Ok(id)
1008    }
1009}