1use alloc::vec::Vec;
19
20use muon::{Chain, Group, Item, Seq};
21use num_bigint::BigInt;
22
23use crate::builtins::Builtin;
24use crate::code::{
25 len32, Builder, ChunkId, HomeLeaf, Member, ModId, Node, NodeId, Pat, PatId, Run, Text,
26};
27use crate::module::{ImportSpec, ModuleName};
28use crate::resolve::{Barrier, Ref, Scope};
29use crate::source::{report, ChunkSpan, DocSource, Pos};
30use crate::sym::Sym;
31use crate::Ctx;
32
33fn text(s: &str) -> Text {
35 Text::from(s)
36}
37
38#[derive(Debug, Clone, PartialEq, Eq)]
41pub enum Error {
42 Syntax(muon::ParseError),
44 Parse(ParseError, muon::Span),
47}
48
49impl Error {
50 pub fn span(&self) -> muon::Span {
53 match self {
54 Error::Syntax(e) => muon::Span {
55 offset: e.offset as Pos,
56 length: 0,
57 },
58 Error::Parse(_, span) => *span,
59 }
60 }
61
62 pub fn report(&self, name: &str, text: &str) -> alloc::string::String {
66 let message = match self {
67 Error::Syntax(e) => alloc::format!("syntax error: {:?}", e.kind),
68 Error::Parse(e, _) => alloc::format!("parse error: {e:?}"),
69 };
70 report(name, text, self.span(), &message)
71 }
72}
73
74#[derive(Debug, Clone, PartialEq, Eq)]
78pub enum ParseError {
79 MultipleExpressions,
82 EmptyChain,
84 AbsWithoutBody,
86 BadBinder,
89 UnexpectedBinder,
92 BadSymbol,
96 CombinatorDeferred,
100 DiscardReference,
103 ReservedName,
106 MalformedNumber,
110 PunctAtAtom,
115 MalformedMapKey,
119 LetMissingBinders,
122 LetMissingBody,
124 RecurMissingBinders,
127 RecurMissingBody,
129 RecurShadowsOuter(Text),
134 MalformedBinding,
137 ReservedKeyword,
140 BadPattern,
143 ComparandNotAtom,
147 BareLiteralHeader,
154 LoneSurrogate,
158 LetOrUnparenthesized,
162 UnknownType,
165 OrBindersMismatch,
167 MalformedPipe,
170 UnboundName(Text),
177 BadModuleItemName,
182 DuplicateModuleItem,
188 MalformedImport,
194 MisplacedImport,
200 MalformedConst,
206 MisplacedConst,
212 ShadowsImport(Text),
217 ShadowsIota(Text),
220 MalformedLocal,
226 MisplacedLocal,
231 ShadowsLocal(Text),
234 ShadowsItem(Text),
241 UnknownReserved(Text),
249 DuplicateReserved(Text),
253 MisplacedReserved,
259 OutsideModule(Text),
266 NotAPrototype(Text),
272 BinderRunGlued,
277 FloatLiteralUnsupported,
283 ReservedLiteralForm,
291 BareListLiteral,
295 BareMapLiteral,
303 BlockTrailingBinding,
309 CaseMissingArms,
313 CaseSubjectExtra,
317 ArmNotBinder,
320 ArmMissingBody,
323 WhenMissingCond,
326}
327
328#[derive(Debug)]
332struct Failure(ParseError, ChunkSpan);
333
334type Parsed<T> = Result<T, Failure>;
336
337impl From<ParseError> for Failure {
338 fn from(error: ParseError) -> Self {
339 Failure(error, ChunkSpan::NONE)
340 }
341}
342
343impl Failure {
344 fn or_at(self, span: impl FnOnce() -> ChunkSpan) -> Self {
346 match self.1.get() {
347 Some(_) => self,
348 None => Failure(self.0, span()),
349 }
350 }
351
352 fn into_error(self, src: Source<'_>) -> Error {
355 let span = self.1.in_doc(src.base).unwrap_or_default();
356 Error::Parse(self.0, span)
357 }
358}
359
360pub(crate) enum Root<'p> {
366 Closed,
368 Open,
370 Prelude(&'p [Text]),
372 Module(ChunkId, ModId),
375}
376
377#[derive(Clone, Copy)]
379pub(crate) enum Body<'p> {
380 Expr,
383 Block { binders: &'p [Text] },
388}
389
390impl Ctx {
391 pub(crate) fn compile_expr(
394 &self,
395 src: &str,
396 root: Root<'_>,
397 body: Body<'_>,
398 ) -> Result<ChunkId, Error> {
399 let seq = muon::parse(src).map_err(Error::Syntax)?;
400 let mut scope = match root {
401 Root::Closed => Scope::new(self, Vec::new(), 0, false, Vec::new()),
402 Root::Open => Scope::new(self, Vec::new(), 0, true, Vec::new()),
403 Root::Prelude(prelude) => {
404 let names = prelude.iter().map(|n| self.intern(n)).collect();
405 Scope::new(self, names, 0, false, Vec::new())
406 }
407 Root::Module(chunk, module) => {
408 let code = self.chunk(chunk);
409 let m = code.module(module);
410 let names = |members: &[Member]| members.iter().map(|m| m.name).collect();
411 let (items, rest) = code.members(m).split_at(m.items as usize);
412 let (locals, iotas) = rest.split_at(m.locals as usize);
413 let members = Barrier::Module {
414 items: names(items),
415 locals: names(locals),
416 iotas: names(iotas),
417 };
418 let frame = code.frame_names(m).to_vec();
419 Scope::new(
420 self,
421 frame,
422 m.imports.len as usize,
423 false,
424 alloc::vec![members],
425 )
426 }
427 };
428 let mut b = Builder::new();
429 let src = Source {
430 text: src,
431 base: b.add_doc(None, src),
432 };
433 if let Body::Block { binders } = body {
434 for name in binders {
435 let bound = scope.bind(self.intern(name));
436 bound.map_err(|e| Failure(e, ChunkSpan::NONE).into_error(src))?;
437 }
438 }
439 let mut p = Parser::new(self, scope, b, src);
440 let top = p.b.enter_module();
441 let (body, span) = match body {
442 Body::Expr => p.program(&seq),
443 Body::Block { .. } => p.block_program(&seq),
444 }
445 .map_err(|f| f.into_error(src))?;
446 let body = p.b.push(body, span);
447 let mark = p.b.member_scratch.len();
448 p.b.leave_module(top, None, mark, 0, 0, &[], Vec::new(), body);
449 Ok(self.add_built(p.b, None, "__eval_"))
450 }
451
452 pub(crate) fn compile_source(
461 &self,
462 src: &str,
463 frame: &[Text],
464 name: Option<ModuleName>,
465 doc: Option<DocSource>,
466 ) -> Result<ChunkId, Error> {
467 let seq = muon::parse(src).map_err(Error::Syntax)?;
468 let b = self.emit_module(&seq, src, doc, frame, name.clone())?;
469 Ok(self.add_built(b, name, "__module_"))
470 }
471
472 fn emit_module(
473 &self,
474 seq: &Seq<'_>,
475 src: &str,
476 doc: Option<DocSource>,
477 frame: &[Text],
478 name: Option<ModuleName>,
479 ) -> Result<Builder, Error> {
480 let mut b = Builder::new();
481 let source = Source {
482 text: src,
483 base: b.add_doc(doc, src),
484 };
485 let chains = chain_slices(seq);
486 let decls = declarations(&chains, self, source).map_err(|f| f.into_error(source))?;
487 let items = sorted(&decls.items);
488 let locals = sorted(&decls.locals);
489 let iotas = sorted(&decls.iotas);
490 let mut slots: Vec<Sym> = decls.imports.iter().map(|(n, _)| *n).collect();
493 slots.extend(frame.iter().map(|n| self.intern(n)));
494 let members = Barrier::Module {
495 items: items.clone(),
496 locals: locals.clone(),
497 iotas: iotas.clone(),
498 };
499 let scope = Scope::new(
500 self,
501 slots.clone(),
502 decls.imports.len(),
503 false,
504 alloc::vec![members],
505 );
506 let mut p = Parser::new(self, scope, b, source);
507 let top = p.b.enter_module();
508 let (mark, body) = p
509 .members(&decls, &items, &locals, &iotas)
510 .map_err(|f| f.into_error(source))?;
511 let specs = decls.imports.into_iter().map(|(_, spec)| spec).collect();
512 let (n_items, n_locals) = (len32(items.len()), len32(locals.len()));
513 p.b.leave_module(top, name, mark, n_items, n_locals, &slots, specs, body);
514 Ok(p.b)
515 }
516}
517
518#[derive(Clone, Copy)]
521struct Source<'s> {
522 text: &'s str,
523 base: Pos,
524}
525
526impl Source<'_> {
527 fn item(self, item: &Item<'_>) -> ChunkSpan {
529 let span = item.span(self.text);
530 ChunkSpan::new(self.base + span.offset, span.length)
531 }
532
533 fn items(self, items: &[&Item<'_>]) -> ChunkSpan {
536 match items {
537 [] => ChunkSpan::NONE,
538 [item] => self.item(item),
539 [first, .., last] => self.item(first).join(self.item(last)),
540 }
541 }
542
543 fn group(self, group: &Group<'_>) -> ChunkSpan {
545 ChunkSpan::new(self.base + group.span.offset, group.span.length)
546 }
547}
548
549fn sorted(names: &[Sym]) -> Vec<Sym> {
551 let mut names = names.to_vec();
552 names.sort();
553 names
554}
555
556enum Decl<'b, 'a> {
563 Item(Sym, Vec<&'b Item<'a>>),
565 Forward(Sym),
568 Local(Sym, Vec<&'b Item<'a>>),
570 Main(Vec<&'b Item<'a>>),
572}
573
574struct Decls<'b, 'a> {
576 bodies: Vec<(Decl<'b, 'a>, ChunkSpan)>,
578 spans: Vec<(Sym, ChunkSpan)>,
581 items: Vec<Sym>,
583 locals: Vec<Sym>,
585 iotas: Vec<Sym>,
587 imports: Vec<(Sym, ImportSpec)>,
589 has_main: bool,
590}
591
592impl Decls<'_, '_> {
593 fn span(&self, name: Sym) -> ChunkSpan {
597 match self.spans.binary_search_by(|(n, _)| n.cmp(&name)) {
598 Ok(i) => self.spans[i].1,
599 Err(_) => ChunkSpan::NONE,
600 }
601 }
602}
603
604fn declarations<'b, 'a>(
611 chains: &[Vec<&'b Item<'a>>],
612 ctx: &Ctx,
613 src: Source<'_>,
614) -> Parsed<Decls<'b, 'a>> {
615 let mut d = Decls {
616 bodies: Vec::new(),
617 spans: Vec::new(),
618 items: Vec::new(),
619 locals: Vec::new(),
620 iotas: Vec::new(),
621 imports: Vec::new(),
622 has_main: false,
623 };
624 let mut re = Reexports::default();
625 for ci in chains {
626 declaration(ci, ctx, src, &mut d, &mut re).map_err(|f| f.or_at(|| src.items(ci)))?;
627 }
628 let dup = |name: &Sym| {
631 let span = d.spans.iter().rev().find(|(n, _)| n == name);
632 Err(Failure(
633 ParseError::DuplicateModuleItem,
634 span.map_or(ChunkSpan::NONE, |(_, span)| *span),
635 ))
636 };
637 for (name, _) in &d.imports {
638 if d.iotas.contains(name) || !re.imports.contains(name) && d.items.contains(name) {
639 return dup(name);
640 }
641 }
642 for iota in &d.iotas {
643 if !re.iotas.contains(iota) && d.items.contains(iota) {
644 return dup(iota);
645 }
646 }
647 for name in &d.locals {
648 let taken = d.items.contains(name)
649 || d.iotas.contains(name)
650 || d.imports.iter().any(|(n, _)| n == name);
651 if taken {
652 return dup(name);
653 }
654 }
655 d.spans.sort_by_key(|(name, _)| *name);
657 Ok(d)
658}
659
660#[derive(Default)]
662struct Reexports {
663 imports: Vec<Sym>,
664 iotas: Vec<Sym>,
665}
666
667fn declaration<'b, 'a>(
669 ci: &[&'b Item<'a>],
670 ctx: &Ctx,
671 src: Source<'_>,
672 d: &mut Decls<'b, 'a>,
673 re: &mut Reexports,
674) -> Parsed<()> {
675 let span = src.items(ci);
676 let split = ci.iter().position(|it| matches!(it, Item::Punct("=")));
677 if split.is_none() && head_keyword(ci[0]) == Some("import") {
678 let (name, spec) = parse_private_import(ci, ctx, src)?;
679 push_import(&mut d.imports, name, spec)?;
680 return Ok(());
681 }
682 if split.is_none() && head_keyword(ci[0]) == Some("const") {
683 for (name, span) in parse_const_decl(ci, ctx, src)? {
684 push_name(&mut d.iotas, name)?;
685 d.spans.push((name, span));
686 }
687 return Ok(());
688 }
689 if split.is_none() && head_keyword(ci[0]) == Some("local") {
690 for (name, body, span) in parse_local_group(ci, ctx, src)? {
691 push_name(&mut d.locals, name)?;
692 d.spans.push((name, span));
693 d.bodies.push((Decl::Local(name, body), span));
694 }
695 return Ok(());
696 }
697 let eq = split.ok_or(ParseError::MalformedBinding)?;
698 if ci[eq + 1..].iter().any(|it| matches!(it, Item::Punct("="))) {
699 return Err(ParseError::MalformedBinding.into());
700 }
701 let (head, tail) = (&ci[..eq], &ci[eq + 1..]);
702 if head.is_empty() || tail.is_empty() {
703 return Err(ParseError::MalformedBinding.into());
704 }
705 if head.len() > 1 && head_keyword(head[0]) == Some("const") {
706 return Err(ParseError::MalformedConst.into());
707 }
708 if head.len() > 1 && head_keyword(head[0]) == Some("local") {
709 let name = plain_name(&head[1..], ParseError::MalformedLocal, ctx, src)?;
710 push_name(&mut d.locals, name)?;
711 d.spans.push((name, span));
712 d.bodies.push((Decl::Local(name, tail.to_vec()), span));
713 return Ok(());
714 }
715 if let [Item::Sym(s)] = head {
716 if let Some(reserved) = reserved_moditem(s) {
717 if d.has_main {
718 let error = ParseError::DuplicateReserved(text(reserved));
719 return Err(Failure(error, src.items(head)));
720 }
721 d.has_main = true;
722 d.bodies.push((Decl::Main(tail.to_vec()), span));
723 return Ok(());
724 }
725 if s.starts_with("__") {
726 let error = ParseError::UnknownReserved(text(s));
727 return Err(Failure(error, src.items(head)));
728 }
729 }
730 let name = plain_name(head, ParseError::BadModuleItemName, ctx, src)?;
731 if d.items.contains(&name) {
732 return Err(ParseError::DuplicateModuleItem.into());
733 }
734 if head_keyword(tail[0]) == Some("import") {
735 let spec = parse_import_spec(tail)?;
736 push_import(&mut d.imports, name, spec)?;
737 re.imports.push(name);
738 d.items.push(name);
739 d.spans.push((name, span));
740 d.bodies.push((Decl::Forward(name), span));
741 return Ok(());
742 }
743 if head_keyword(tail[0]) == Some("const") {
744 if tail.len() != 1 {
745 return Err(ParseError::MalformedConst.into());
746 }
747 push_name(&mut d.iotas, name)?;
748 re.iotas.push(name);
749 d.items.push(name);
750 d.spans.push((name, span));
751 d.bodies.push((Decl::Forward(name), span));
752 return Ok(());
753 }
754 d.items.push(name);
755 d.spans.push((name, span));
756 d.bodies.push((Decl::Item(name, tail.to_vec()), span));
757 Ok(())
758}
759
760fn reserved_moditem(name: &str) -> Option<&'static str> {
769 match name {
770 "__main" => Some("__main"),
771 _ => None,
772 }
773}
774
775fn push_import(imports: &mut Vec<(Sym, ImportSpec)>, name: Sym, spec: ImportSpec) -> Parsed<()> {
777 if imports.iter().any(|(n, _)| *n == name) {
778 return Err(ParseError::DuplicateModuleItem.into());
779 }
780 imports.push((name, spec));
781 Ok(())
782}
783
784fn push_name(names: &mut Vec<Sym>, name: Sym) -> Parsed<()> {
786 if names.contains(&name) {
787 return Err(ParseError::DuplicateModuleItem.into());
788 }
789 names.push(name);
790 Ok(())
791}
792
793fn parse_private_import<'a>(
799 ci: &[&Item<'a>],
800 ctx: &Ctx,
801 src: Source<'_>,
802) -> Parsed<(Sym, ImportSpec)> {
803 let rest: Vec<&Item<'a>> = match ci[0] {
804 Item::Run(members) => members[1..]
805 .iter()
806 .map(|it| it as &Item<'a>)
807 .chain(ci[1..].iter().copied())
808 .collect(),
809 _ => ci[1..].to_vec(),
810 };
811 match rest.as_slice() {
812 [Item::Str(spec), Item::Sym("as"), rest @ ..] if !rest.is_empty() => {
813 let name = plain_name(rest, ParseError::BadModuleItemName, ctx, src)?;
814 Ok((name, decode_str(spec)?))
815 }
816 _ => Err(ParseError::MalformedImport.into()),
817 }
818}
819
820fn parse_const_decl<'a>(
828 ci: &[&Item<'a>],
829 ctx: &Ctx,
830 src: Source<'_>,
831) -> Parsed<Vec<(Sym, ChunkSpan)>> {
832 let rest: Vec<&Item<'a>> = match ci[0] {
835 Item::Run(members) => members[1..].iter().map(|it| it as &Item<'a>).collect(),
836 _ => ci[1..].to_vec(),
837 };
838 match rest.as_slice() {
839 [Item::Parens(Group { seq, .. }), ..] => {
840 let mut names = Vec::new();
841 for c in chain_slices(seq) {
842 let name = plain_name(&c, ParseError::MalformedConst, ctx, src)?;
843 names.push((name, src.items(&c)));
844 }
845 Ok(names)
846 }
847 rest if !rest.is_empty() => {
848 let name = plain_name(rest, ParseError::MalformedConst, ctx, src)?;
849 Ok(alloc::vec![(name, src.items(rest))])
850 }
851 _ => Err(ParseError::MalformedConst.into()),
852 }
853}
854
855#[allow(clippy::type_complexity)]
860fn parse_local_group<'b, 'a>(
861 ci: &[&'b Item<'a>],
862 ctx: &Ctx,
863 src: Source<'_>,
864) -> Parsed<Vec<(Sym, Vec<&'b Item<'a>>, ChunkSpan)>> {
865 let group = match ci[0] {
866 Item::Run(members) => members.get(1),
867 _ => ci.get(1).copied(),
868 };
869 let Some(Item::Parens(Group { seq, .. })) = group else {
870 return Err(ParseError::MalformedLocal.into());
871 };
872 let mut bindings = Vec::new();
873 for c in chain_slices(seq) {
874 let malformed = || Failure(ParseError::MalformedLocal, src.items(&c));
875 let eq = c
876 .iter()
877 .position(|it| matches!(it, Item::Punct("=")))
878 .ok_or_else(malformed)?;
879 let (head, tail) = (&c[..eq], &c[eq + 1..]);
880 if head.is_empty() || tail.is_empty() {
881 return Err(malformed());
882 }
883 if tail.iter().any(|it| matches!(it, Item::Punct("="))) {
884 return Err(malformed());
885 }
886 bindings.push((
887 plain_name(head, ParseError::MalformedLocal, ctx, src)?,
888 tail.to_vec(),
889 src.items(&c),
890 ));
891 }
892 Ok(bindings)
893}
894
895fn parse_import_spec(tail: &[&Item<'_>]) -> Parsed<ImportSpec> {
898 let spec = match tail {
899 [_import, Item::Str(spec)] => spec,
900 [Item::Run(members)] => match members.as_slice() {
901 [_import, Item::Str(spec)] => spec,
902 _ => return Err(ParseError::MalformedImport.into()),
903 },
904 _ => return Err(ParseError::MalformedImport.into()),
905 };
906 decode_str(spec)
907}
908
909fn plain_name(items: &[&Item<'_>], bad: ParseError, ctx: &Ctx, src: Source<'_>) -> Parsed<Sym> {
912 plain_name_at(items, bad, ctx).map_err(|f| f.or_at(|| src.items(items)))
913}
914
915fn plain_name_at(items: &[&Item<'_>], bad: ParseError, ctx: &Ctx) -> Parsed<Sym> {
917 match items {
918 [Item::Sym(s)] if is_keyword(s) => Err(ParseError::ReservedKeyword.into()),
919 [Item::Sym(s)] if s.starts_with("__") => Err(ParseError::ReservedName.into()),
920 [Item::Sym(s)] if reads_as_number(s) || *s == "_" => Err(bad.into()),
921 [Item::Sym(s)] => Ok(ctx.intern(s)),
922 _ => Err(bad.into()),
923 }
924}
925
926fn reads_as_number(s: &str) -> bool {
928 parse_int(s).is_some() || s.as_bytes()[0].is_ascii_digit()
929}
930
931#[derive(Debug, Clone, Copy, PartialEq, Eq)]
941enum Slot {
942 Value,
944 Applied,
947 AppliedElems,
950 Body,
953}
954
955type Spanned = (Node, ChunkSpan);
957
958enum Built {
960 Node(Node, ChunkSpan),
962 Spine(Spine),
965}
966
967struct Spine {
970 mark: usize,
971 callee: Option<Builtin>,
973 span: ChunkSpan,
975}
976
977struct Head {
980 pats: usize,
981 chain: Option<usize>,
985}
986
987enum SymRef {
989 Home,
990 Int(BigInt),
991 Builtin(Builtin),
992 Name(Sym),
993}
994
995const MAX_HEAD: usize = u8::MAX as usize;
998
999struct Parser<'c, 's> {
1001 ctx: &'c Ctx,
1002 b: Builder,
1003 scope: Scope<'c>,
1004 heads: Vec<Head>,
1006 src: Source<'s>,
1008}
1009
1010impl<'c, 's> Parser<'c, 's> {
1011 fn new(ctx: &'c Ctx, scope: Scope<'c>, b: Builder, src: Source<'s>) -> Self {
1013 Parser {
1014 ctx,
1015 b,
1016 scope,
1017 heads: Vec::new(),
1018 src,
1019 }
1020 }
1021
1022 fn program(&mut self, seq: &Seq<'_>) -> Parsed<Spanned> {
1025 match chain_slices(seq).as_slice() {
1026 [] => Ok(self.close(Built::Node(Node::Unit, ChunkSpan::NONE))),
1027 [items] => {
1028 let built = self.expr(items, Slot::Value)?;
1029 Ok(self.close(built))
1030 }
1031 [_, second, ..] => Err(Failure(
1032 ParseError::MultipleExpressions,
1033 self.src.items(second),
1034 )),
1035 }
1036 }
1037
1038 fn block_program(&mut self, seq: &Seq<'_>) -> Parsed<Spanned> {
1041 if braces_contain_colon(seq) {
1042 return Err(ParseError::BareMapLiteral.into());
1043 }
1044 let clauses = chain_slices(seq);
1045 let span = match (clauses.first(), clauses.last()) {
1046 (Some(first), Some(last)) => self.src.items(first).join(self.src.items(last)),
1047 _ => ChunkSpan::NONE,
1048 };
1049 let built = self.build_block(clauses, Slot::Value, span)?;
1050 Ok(self.close(built))
1051 }
1052
1053 fn members(
1060 &mut self,
1061 decls: &Decls<'_, '_>,
1062 items: &[Sym],
1063 locals: &[Sym],
1064 iotas: &[Sym],
1065 ) -> Parsed<(usize, NodeId)> {
1066 let mark = self.b.member_scratch.len();
1067 for &name in items.iter().chain(locals).chain(iotas) {
1068 let member = Member {
1069 name,
1070 node: NodeId::NONE,
1071 };
1072 self.b.member_scratch.push((member, decls.span(name)));
1073 }
1074 let slot = |name: Sym, names: &[Sym]| {
1075 names
1076 .binary_search(&name)
1077 .expect("a declared name has a slot")
1078 };
1079 let mut main = NodeId::NONE;
1080 for (decl, span) in &decls.bodies {
1081 let (index, node) = match decl {
1082 Decl::Item(name, body) => (slot(*name, items), self.body(body)?),
1083 Decl::Forward(name) => {
1084 let node = self.name_ref(*name).map_err(|f| f.or_at(|| *span))?;
1085 (slot(*name, items), self.b.push(node, *span))
1086 }
1087 Decl::Local(name, body) => (items.len() + slot(*name, locals), self.body(body)?),
1088 Decl::Main(body) => {
1089 main = self.body(body)?;
1090 continue;
1091 }
1092 };
1093 self.b.member_scratch[mark + index].0.node = node;
1094 }
1095 Ok((mark, main))
1096 }
1097
1098 fn body(&mut self, items: &[&Item<'_>]) -> Parsed<NodeId> {
1100 let built = self.expr(items, Slot::Value)?;
1101 Ok(self.child(built))
1102 }
1103
1104 fn close(&mut self, built: Built) -> Spanned {
1110 match built {
1111 Built::Node(node, span) => (node, span),
1112 Built::Spine(spine) => self.close_spine(spine),
1113 }
1114 }
1115
1116 fn child(&mut self, built: Built) -> NodeId {
1118 let (node, span) = self.close(built);
1119 self.b.push(node, span)
1120 }
1121
1122 fn close_spine(&mut self, spine: Spine) -> Spanned {
1124 let len = self.b.scratch.len() - spine.mark;
1125 if len == 1 {
1126 return self.b.scratch.pop().expect("a spine has a callee");
1127 }
1128 let app = Node::App {
1129 len: len32(len),
1130 args: self.b.push_run(Run::App, spine.mark),
1131 };
1132 (app, spine.span)
1133 }
1134
1135 fn start(&mut self, callee: Spanned) -> Spine {
1137 let mark = self.b.scratch.len();
1138 self.b.scratch.push(callee);
1139 Spine {
1140 mark,
1141 callee: builtin_of(callee.0),
1142 span: callee.1,
1143 }
1144 }
1145
1146 fn open(&mut self, built: Built) -> Spine {
1150 match built {
1151 Built::Spine(spine) => spine,
1152 Built::Node(Node::App { len, args }, span) => {
1153 let mark = self.b.scratch.len();
1154 for i in 0..len {
1155 let node = self.b.node(args.nth(i));
1156 self.b.scratch.push(node);
1157 }
1158 Spine {
1159 mark,
1160 callee: builtin_of(self.b.scratch[mark].0),
1161 span,
1162 }
1163 }
1164 Built::Node(node, span) => self.start((node, span)),
1165 }
1166 }
1167
1168 fn arg_slot(&self, spine: &Spine) -> Slot {
1170 let i = self.b.scratch.len() - spine.mark - 1;
1171 match spine.callee {
1172 Some(op) if op.applies_arg(i) => Slot::Applied,
1173 Some(op) if op.applies_elements_of(i) => Slot::AppliedElems,
1174 _ => Slot::Value,
1175 }
1176 }
1177
1178 fn next_slot(&self, spine: &Option<Spine>) -> Slot {
1181 match spine {
1182 None => Slot::Applied,
1183 Some(spine) => self.arg_slot(spine),
1184 }
1185 }
1186
1187 fn extend(&mut self, spine: &mut Spine, arg: Spanned) {
1191 spine.span = spine.span.join(arg.1);
1192 if self.b.scratch.len() - spine.mark == 1 {
1193 if let (Some(ns), Node::Symbol(m)) = (spine.callee, arg.0) {
1194 if let Some(op) = ns.member(m) {
1195 self.b.scratch[spine.mark] = (Node::Builtin(op), spine.span);
1196 spine.callee = Some(op);
1197 return;
1198 }
1199 }
1200 }
1201 self.b.scratch.push(arg);
1202 }
1203
1204 fn push_arg(&mut self, spine: &mut Option<Spine>, arg: Spanned) {
1206 match spine {
1207 None => *spine = Some(self.start(arg)),
1208 Some(spine) => self.extend(spine, arg),
1209 }
1210 }
1211
1212 fn expr(&mut self, items: &[&Item<'_>], slot: Slot) -> Parsed<Built> {
1220 let src = self.src;
1221 self.pipeline(items, slot)
1222 .map_err(|f| f.or_at(|| src.items(items)))
1223 }
1224
1225 fn pipeline(&mut self, items: &[&Item<'_>], slot: Slot) -> Parsed<Built> {
1227 if items.is_empty() {
1228 return Err(ParseError::EmptyChain.into());
1229 }
1230 match items.iter().rposition(|it| matches!(it, Item::Punct("|>"))) {
1234 None => self.segment(items, slot),
1235 Some(k) => {
1236 let (left, right) = (&items[..k], &items[k + 1..]);
1237 if left.is_empty() || right.is_empty() {
1238 let pipe = self.src.item(items[k]);
1239 return Err(Failure(ParseError::MalformedPipe, pipe));
1240 }
1241 let r = self.segment(right, Slot::Applied)?;
1242 let mut spine = self.open(r);
1243 let slot = self.arg_slot(&spine);
1244 let l = self.expr(left, slot)?;
1245 let l = self.close(l);
1246 self.extend(&mut spine, l);
1247 Ok(Built::Spine(spine))
1248 }
1249 }
1250 }
1251
1252 fn segment(&mut self, items: &[&Item<'_>], slot: Slot) -> Parsed<Built> {
1257 match items.iter().position(|it| is_split_point(it)) {
1258 None => self.app_spine(items, slot),
1259 Some(0) => match head_keyword(items[0]) {
1260 Some("let") | Some("recur") => self.let_or_recur(items[0], items, slot),
1261 Some("case") => self.case(items, slot),
1262 _ => self.binder(items, slot),
1263 },
1264 Some(k) => {
1265 let f = self.segment(&items[..k], Slot::Applied)?;
1266 let mut spine = self.open(f);
1267 let slot = self.arg_slot(&spine);
1268 let arg = self.segment(&items[k..], slot)?;
1269 let arg = self.close(arg);
1270 self.extend(&mut spine, arg);
1271 Ok(Built::Spine(spine))
1272 }
1273 }
1274 }
1275
1276 fn app_spine(&mut self, items: &[&Item<'_>], slot: Slot) -> Parsed<Built> {
1280 if let [item] = items {
1281 match item {
1282 Item::Parens(group) => return self.group(group, slot),
1283 Item::Run(_) => {}
1284 _ => return self.aexpr(item, slot),
1285 }
1286 }
1287 let mut spine: Option<Spine> = None;
1288 for (i, it) in items.iter().enumerate() {
1289 match *it {
1290 Item::Run(members) if i == 0 => {
1291 let src = self.src;
1292 check_run_head(members).map_err(|f| f.or_at(|| src.item(it)))?;
1293 let members = if is_self_head(members) {
1294 let new = self.home(HomeLeaf::New)?;
1295 let span = self.src.item(&members[0]);
1296 self.push_arg(&mut spine, (new, span));
1297 &members[1..]
1298 } else {
1299 &members[..]
1300 };
1301 for m in members {
1302 self.expand_arg(m, &mut spine)?;
1303 }
1304 }
1305 Item::Prefixed { sigil: '#', item }
1306 if i == 0 && matches!(item.as_ref(), Item::Sym("Self")) =>
1307 {
1308 let new = self.home(HomeLeaf::New)?;
1309 let span = self.src.item(it);
1310 self.push_arg(&mut spine, (new, span));
1311 }
1312 _ => self.expand_arg(it, &mut spine)?,
1313 }
1314 }
1315 let spine = spine.expect("a spine has at least one item");
1316 let len = self.b.scratch.len() - spine.mark;
1317 if len == 1 {
1318 if let Node::Home {
1319 leaf: HomeLeaf::New,
1320 ..
1321 } = self.b.scratch[spine.mark].0
1322 {
1323 let span = self.b.scratch[spine.mark].1;
1324 return Err(Failure(ParseError::ReservedLiteralForm, span));
1325 }
1326 let (node, span) = self.close_spine(spine);
1327 return Ok(Built::Node(node, span));
1328 }
1329 Ok(Built::Spine(spine))
1330 }
1331
1332 fn expand_arg(&mut self, item: &Item<'_>, spine: &mut Option<Spine>) -> Parsed<()> {
1336 match item {
1337 Item::Parens(group) => {
1338 let chains = chain_slices(&group.seq);
1339 if chains.is_empty() {
1340 let span = self.src.group(group);
1341 self.push_arg(spine, (Node::Unit, span));
1342 }
1343 for chain in &chains {
1344 let slot = self.next_slot(spine);
1345 let arg = self.expr(chain, slot)?;
1346 let arg = self.close(arg);
1347 self.push_arg(spine, arg);
1348 }
1349 if let Some(spine) = spine {
1351 spine.span = spine.span.join(self.src.group(group));
1352 }
1353 Ok(())
1354 }
1355 Item::Prefixed { sigil: '.', item }
1356 if matches!(item.as_ref(), Item::Sym("Self")) && spine.is_some() =>
1357 {
1358 let acc = self.close_spine(spine.take().expect("checked"));
1359 let value = self.home(HomeLeaf::Value)?;
1360 let value_span = self.src.item(item);
1361 let span = acc.1.join(value_span);
1362 let mark = self.b.scratch.len();
1363 self.b.scratch.push((value, value_span));
1364 self.b.scratch.push(acc);
1365 let read = Node::App {
1366 len: 2,
1367 args: self.b.push_run(Run::App, mark),
1368 };
1369 *spine = Some(self.start((read, span)));
1370 Ok(())
1371 }
1372 _ => {
1373 let slot = self.next_slot(spine);
1374 let arg = self.aexpr(item, slot)?;
1375 let arg = self.close(arg);
1376 self.push_arg(spine, arg);
1377 Ok(())
1378 }
1379 }
1380 }
1381
1382 fn group(&mut self, group: &Group<'_>, slot: Slot) -> Parsed<Built> {
1385 let chains = chain_slices(&group.seq);
1386 match chains.as_slice() {
1387 [] => Ok(Built::Node(Node::Unit, self.src.group(group))),
1388 [chain] => self.expr(chain, slot),
1389 chains => {
1390 let mut spine = None;
1391 for chain in chains {
1392 let slot = self.next_slot(&spine);
1393 let arg = self.expr(chain, slot)?;
1394 let arg = self.close(arg);
1395 self.push_arg(&mut spine, arg);
1396 }
1397 let mut spine = spine.expect("a group of several chains");
1398 spine.span = self.src.group(group);
1399 Ok(Built::Spine(spine))
1400 }
1401 }
1402 }
1403
1404 fn aexpr(&mut self, item: &Item<'_>, slot: Slot) -> Parsed<Built> {
1406 let src = self.src;
1407 self.atom_expr(item, slot)
1408 .map_err(|f| f.or_at(|| src.item(item)))
1409 }
1410
1411 fn atom_expr(&mut self, item: &Item<'_>, slot: Slot) -> Parsed<Built> {
1413 let node = match item {
1414 Item::Sym(s) => self.sym(s)?,
1415 Item::Prefixed { sigil: '.', item } => self.dot_symbol(item)?,
1416 Item::Brackets(_) => return Err(ParseError::BareListLiteral.into()),
1417 Item::Parens(group) => return self.group(group, slot),
1418 Item::Str(s) => self.b.str(decode_str(s)?),
1419 Item::Braces(group) => return self.block(group, slot),
1420 Item::Punct(".") => return Err(ParseError::CombinatorDeferred.into()),
1421 Item::Punct(_) => return Err(ParseError::PunctAtAtom.into()),
1422 Item::Comm(_) => return Err(ParseError::EmptyChain.into()),
1423 Item::Prefixed { sigil: '#', item } => match item.as_ref() {
1424 Item::Brackets(Group { seq, .. }) => self.list(seq, slot)?,
1425 Item::Braces(Group { seq, .. }) => self.map(seq)?,
1426 _ => return Err(ParseError::ReservedLiteralForm.into()),
1427 },
1428 Item::Prefixed { .. } => return Err(ParseError::UnexpectedBinder.into()),
1429 Item::Run(members) => {
1430 check_run_head(members)?;
1431 let items: Vec<&Item<'_>> = members.iter().collect();
1432 return self.expr(&items, slot);
1433 }
1434 };
1435 Ok(Built::Node(node, self.src.item(item)))
1436 }
1437
1438 fn sym(&mut self, s: &str) -> Parsed<Node> {
1440 let r = classify(s, self.ctx)?;
1441 self.resolve_sym(r)
1442 }
1443
1444 fn resolve_sym(&mut self, r: SymRef) -> Parsed<Node> {
1445 match r {
1446 SymRef::Home => self.home(HomeLeaf::Module),
1447 SymRef::Int(n) => Ok(self.b.int(n)),
1448 SymRef::Builtin(op) => Ok(Node::Builtin(op)),
1449 SymRef::Name(name) => self.name_ref(name),
1450 }
1451 }
1452
1453 fn name_ref(&mut self, name: Sym) -> Parsed<Node> {
1455 Ok(match self.scope.reference(name)? {
1456 Ref::Local(index) => Node::Local { name, index },
1457 Ref::Item { index, depth } => Node::ModItem { index, depth, name },
1458 Ref::Builtin(op) => Node::Builtin(op),
1459 })
1460 }
1461
1462 fn home(&mut self, leaf: HomeLeaf) -> Parsed<Node> {
1464 let depth = self
1465 .scope
1466 .home_depth()
1467 .ok_or_else(|| ParseError::OutsideModule(text(leaf.name())))?;
1468 Ok(Node::Home { leaf, depth })
1469 }
1470
1471 fn dot_symbol(&mut self, item: &Item<'_>) -> Parsed<Node> {
1473 match item {
1474 Item::Sym(s) => Ok(Node::Symbol(self.ctx.intern(s))),
1475 _ => Err(ParseError::BadSymbol.into()),
1476 }
1477 }
1478
1479 fn list(&mut self, seq: &Seq<'_>, slot: Slot) -> Parsed<Node> {
1483 let elem_slot = match slot {
1484 Slot::AppliedElems => Slot::Applied,
1485 _ => Slot::Value,
1486 };
1487 let chains = chain_slices(seq);
1488 let mark = self.b.scratch.len();
1489 for chain in &chains {
1490 let elem = self.expr(chain, elem_slot)?;
1491 let elem = self.close(elem);
1492 self.b.scratch.push(elem);
1493 }
1494 Ok(Node::List {
1495 len: len32(chains.len()),
1496 elems: self.b.push_run(Run::List, mark),
1497 })
1498 }
1499
1500 fn map(&mut self, seq: &Seq<'_>) -> Parsed<Node> {
1505 let chains = chain_slices(seq);
1506 let n = chains.len();
1507 let mark = self.b.scratch.len();
1508 self.b
1509 .scratch
1510 .resize(mark + 2 * n, (Node::Unit, ChunkSpan::NONE));
1511 for (i, chain) in chains.iter().enumerate() {
1512 let src = self.src;
1513 let (key, value) = self
1514 .entry(chain)
1515 .map_err(|f| f.or_at(|| src.items(chain)))?;
1516 self.b.scratch[mark + i] = key;
1517 self.b.scratch[mark + n + i] = value;
1518 }
1519 Ok(Node::Map {
1520 len: len32(n),
1521 entries: self.b.push_run(Run::Map, mark),
1522 })
1523 }
1524
1525 fn entry(&mut self, items: &[&Item<'_>]) -> Parsed<(Spanned, Spanned)> {
1531 if items.len() < 2 || !matches!(items[1], Item::Punct(":")) {
1532 return Err(ParseError::MalformedMapKey.into());
1533 }
1534 let src = self.src;
1535 let key = self
1536 .map_key(items[0])
1537 .map_err(|f| f.or_at(|| src.item(items[0])))?;
1538 let value_items = &items[2..];
1539 let value = if value_items.is_empty() {
1540 (Node::Unit, self.src.item(items[1]))
1542 } else {
1543 let value = self.expr(value_items, Slot::Value)?;
1544 self.close(value)
1545 };
1546 Ok((key, value))
1547 }
1548
1549 fn map_key(&mut self, item: &Item<'_>) -> Parsed<Spanned> {
1558 match item {
1559 Item::Sym(s) if s.as_bytes()[0].is_ascii_digit() => {
1560 Err(ParseError::MalformedMapKey.into())
1561 }
1562 Item::Sym(s) => Ok((Node::Symbol(self.ctx.intern(s)), self.src.item(item))),
1563 Item::Braces(_) => Err(ParseError::BareMapLiteral.into()),
1566 Item::Prefixed { sigil: '.', .. }
1567 | Item::Prefixed { sigil: '#', .. }
1568 | Item::Brackets(_)
1569 | Item::Parens(_)
1570 | Item::Str(_) => {
1571 let key = self.aexpr(item, Slot::Value)?;
1572 Ok(self.close(key))
1573 }
1574 Item::Run(members) => {
1578 let head =
1579 check_path(members, self.ctx).map_err(|_| ParseError::MalformedMapKey)?;
1580 self.path(head, members)
1581 }
1582 _ => Err(ParseError::MalformedMapKey.into()),
1583 }
1584 }
1585
1586 fn block(&mut self, group: &Group<'_>, slot: Slot) -> Parsed<Built> {
1591 if braces_contain_colon(&group.seq) {
1592 return Err(ParseError::BareMapLiteral.into());
1593 }
1594 let span = self.src.group(group);
1595 self.build_block(chain_slices(&group.seq), slot, span)
1596 }
1597
1598 fn build_block(
1613 &mut self,
1614 clauses: Vec<Vec<&Item<'_>>>,
1615 slot: Slot,
1616 span: ChunkSpan,
1617 ) -> Parsed<Built> {
1618 let Some((last, leading)) = clauses.split_last() else {
1619 return Ok(Built::Node(Node::Unit, span));
1620 };
1621 if clause_is_binding(last) {
1622 let span = self.src.items(last);
1623 return Err(Failure(ParseError::BlockTrailingBinding, span));
1624 }
1625 if leading.is_empty() {
1626 return self.expr(last, slot);
1627 }
1628 let (mark, pat_mark) = (self.b.scratch.len(), self.b.pat_scratch.len());
1629 let locals = self.scope.mark();
1630 for ci in leading {
1631 let (pat, value) = if clause_is_binding(ci) {
1632 let src = self.src;
1633 let (head, tail) = split_binding(ci).map_err(|f| f.or_at(|| src.items(ci)))?;
1634 let value = self.expr(tail, Slot::Value)?;
1635 let value = self.close(value);
1636 ((self.pattern(head)?, self.src.items(head)), value)
1637 } else {
1638 let value = self.expr(ci, Slot::Value)?;
1639 ((Pat::None, ChunkSpan::NONE), self.close(value))
1640 };
1641 self.b.pat_scratch.push(pat);
1642 self.b.scratch.push(value);
1643 }
1644 let value = self.expr(last, Slot::Value)?;
1645 let value = self.close(value);
1646 self.b.pat_scratch.push((Pat::None, ChunkSpan::NONE));
1647 self.b.scratch.push(value);
1648 self.scope.truncate(locals);
1649 let block = Node::Block {
1650 len: len32(clauses.len()),
1651 binds: self.b.push_pat_run(Run::Block, pat_mark),
1652 exprs: self.b.push_run(Run::Block, mark),
1653 };
1654 Ok(Built::Node(block, span))
1655 }
1656
1657 fn let_or_recur(&mut self, head: &Item<'_>, items: &[&Item<'_>], slot: Slot) -> Parsed<Built> {
1660 let is_recur = head_keyword(head) == Some("recur");
1661 let at = self.src.items(&items[..items.len().min(2)]);
1663 let missing = || {
1664 let error = if is_recur {
1665 ParseError::RecurMissingBinders
1666 } else {
1667 ParseError::LetMissingBinders
1668 };
1669 Failure(error, at)
1670 };
1671 let (group_item, body_items): (&Item<'_>, &[&Item<'_>]) = match head {
1672 Item::Run(members) if members.len() == 2 => (&members[1], &items[1..]),
1673 Item::Run(_) => return Err(missing()),
1674 _ => (*items.get(1).ok_or_else(missing)?, &items[2..]),
1675 };
1676 let group = match group_item {
1677 Item::Parens(Group { seq, .. }) => seq,
1678 _ => return Err(missing()),
1679 };
1680 let span = self.src.items(items);
1681 if is_recur {
1682 self.recur(group, body_items, slot, span)
1683 } else {
1684 self.let_block(group, body_items, slot, span)
1685 }
1686 }
1687
1688 fn let_block(
1691 &mut self,
1692 group: &Seq<'_>,
1693 body_items: &[&Item<'_>],
1694 slot: Slot,
1695 span: ChunkSpan,
1696 ) -> Parsed<Built> {
1697 if body_items.is_empty() {
1698 return Err(ParseError::LetMissingBody.into());
1699 }
1700 let mut clauses = chain_slices(group);
1701 for ci in &clauses {
1702 if !clause_is_binding(ci) {
1703 return Err(Failure(ParseError::MalformedBinding, self.src.items(ci)));
1704 }
1705 }
1706 clauses.push(body_items.to_vec());
1707 self.build_block(clauses, slot, span)
1708 }
1709
1710 fn recur(
1715 &mut self,
1716 group: &Seq<'_>,
1717 body_items: &[&Item<'_>],
1718 slot: Slot,
1719 span: ChunkSpan,
1720 ) -> Parsed<Built> {
1721 if body_items.is_empty() {
1722 return Err(ParseError::RecurMissingBody.into());
1723 }
1724 let chains = chain_slices(group);
1725 let decls = declarations(&chains, self.ctx, self.src)?;
1726 if !decls.imports.is_empty() {
1727 return Err(ParseError::MisplacedImport.into());
1728 }
1729 if let Some(&iota) = decls.iotas.first() {
1730 return Err(Failure(ParseError::MisplacedConst, decls.span(iota)));
1731 }
1732 if let Some(&local) = decls.locals.first() {
1733 return Err(Failure(ParseError::MisplacedLocal, decls.span(local)));
1734 }
1735 if let Some((_, span)) = decls
1736 .bodies
1737 .iter()
1738 .find(|(d, _)| matches!(d, Decl::Main(_)))
1739 {
1740 return Err(Failure(ParseError::MisplacedReserved, *span));
1741 }
1742 if decls.items.is_empty() {
1743 return self.segment(body_items, slot);
1744 }
1745 let items = sorted(&decls.items);
1746 self.scope.push_group(items.clone()).map_err(|e| {
1747 let at = match &e {
1748 ParseError::RecurShadowsOuter(name) => decls.span(self.ctx.intern(name)),
1749 _ => span,
1750 };
1751 Failure(e, at)
1752 })?;
1753 let id = self.b.enter_module();
1754 let (mark, _) = self.members(&decls, &items, &[], &[])?;
1755 let body = self.segment(body_items, Slot::Value)?;
1756 let body = self.child(body);
1757 self.scope.pop_group();
1758 let n = len32(items.len());
1759 self.b
1760 .leave_module(id, None, mark, n, 0, &[], Vec::new(), body);
1761 Ok(Built::Node(Node::Recur(id), span))
1762 }
1763
1764 fn case(&mut self, items: &[&Item<'_>], slot: Slot) -> Parsed<Built> {
1767 let span = self.src.items(items);
1768 let missing = || Failure(ParseError::CaseMissingArms, span);
1769 let mut rest: Vec<&Item<'_>> = Vec::new();
1770 if let Item::Run(members) = items[0] {
1771 rest.extend(members[1..].iter());
1772 }
1773 rest.extend_from_slice(&items[1..]);
1774 let (last, subject_items) = rest.split_last().ok_or_else(missing)?;
1775 let arms = match last {
1776 Item::Braces(Group { seq, .. }) => chain_slices(seq),
1777 _ => return Err(missing()),
1778 };
1779 if arms.is_empty() {
1780 return Err(missing());
1781 }
1782 match subject_items {
1783 [] => {
1784 let arg = self.ctx.intern("__arg");
1785 let depth = self.begin_abs(slot);
1787 self.param(span, |p| {
1788 p.scope.bind(arg)?;
1789 Ok(Pat::Bind(arg))
1790 })?;
1791 let subject = self.name_ref(arg)?;
1792 let body = self.case_node((subject, span), &arms)?;
1793 self.end_abs(depth, Built::Node(body, span), span)
1794 }
1795 [subject] => {
1796 let subject = self.aexpr(subject, Slot::Value)?;
1797 let subject = self.close(subject);
1798 Ok(Built::Node(self.case_node(subject, &arms)?, span))
1799 }
1800 _ => Err(Failure(
1801 ParseError::CaseSubjectExtra,
1802 self.src.items(subject_items),
1803 )),
1804 }
1805 }
1806
1807 fn case_node(&mut self, subject: Spanned, arms: &[Vec<&Item<'_>>]) -> Parsed<Node> {
1809 let (mark, pat_mark) = (self.b.scratch.len(), self.b.pat_scratch.len());
1810 for items in arms {
1811 let inner = match items.first() {
1812 Some(Item::Prefixed { sigil: '&', item }) => item.as_ref(),
1813 _ => return Err(Failure(ParseError::ArmNotBinder, self.src.items(items))),
1814 };
1815 if is_bare_literal_header(inner) {
1816 let span = self.src.item(inner);
1817 return Err(Failure(ParseError::BareLiteralHeader, span));
1818 }
1819 let locals = self.scope.mark();
1820 let base = (self.pattern(&[inner])?, self.src.item(inner));
1821 let (pat, rest) = self.guarded(base, &items[1..])?;
1822 if rest.is_empty() {
1823 return Err(Failure(ParseError::ArmMissingBody, self.src.items(items)));
1824 }
1825 let body = self.expr(rest, Slot::Value)?;
1826 let body = self.close(body);
1827 self.scope.truncate(locals);
1828 self.b.pat_scratch.push(pat);
1829 self.b.scratch.push(body);
1830 }
1831 self.b.scratch.push(subject);
1832 Ok(Node::Case {
1833 len: len32(arms.len()),
1834 conds: self.b.push_pat_run(Run::Case, pat_mark),
1835 exprs: self.b.push_run(Run::Case, mark),
1836 })
1837 }
1838
1839 fn binder(&mut self, items: &[&Item<'_>], slot: Slot) -> Parsed<Built> {
1849 if items.len() == 1 {
1850 return Err(ParseError::AbsWithoutBody.into());
1851 }
1852 let inner = match items[0] {
1853 Item::Prefixed { sigil: '&', item } => item.as_ref(),
1854 _ => return Err(ParseError::UnexpectedBinder.into()),
1855 };
1856 let span = self.src.items(items);
1857 let depth = self.begin_abs(slot);
1858 let rest = if matches!(items.get(1), Some(it) if is_when_kw(it))
1859 && !matches!(inner, Item::Parens(_))
1860 {
1861 if is_bare_literal_header(inner) {
1862 let span = self.src.item(inner);
1863 return Err(Failure(ParseError::BareLiteralHeader, span));
1864 }
1865 let mut rest: &[&Item<'_>] = &[];
1866 let base_span = self.src.item(inner);
1867 self.param_spanned(|p| {
1868 let base = (p.pattern(&[inner])?, base_span);
1869 let (pat, after) = p.guarded(base, &items[1..])?;
1870 rest = after;
1871 Ok(pat)
1872 })?;
1873 if rest.is_empty() {
1874 return Err(ParseError::AbsWithoutBody.into());
1875 }
1876 rest
1877 } else {
1878 match inner {
1879 Item::Parens(group) => {
1883 let params = chain_slices(&group.seq);
1884 if params.is_empty() {
1885 self.param(self.src.group(group), |_| Ok(Pat::Unit))?;
1886 }
1887 for chain in ¶ms {
1888 self.param(self.src.items(chain), |p| p.pattern(chain))?;
1889 }
1890 }
1891 it if is_bare_literal_header(it) => {
1895 let span = self.src.item(it);
1896 return Err(Failure(ParseError::BareLiteralHeader, span));
1897 }
1898 other => self.param(self.src.item(other), |p| p.pattern(&[other]))?,
1899 }
1900 &items[1..]
1901 };
1902 let body = self.segment(rest, Slot::Body)?;
1903 self.end_abs(depth, body, span)
1904 }
1905
1906 fn begin_abs(&mut self, slot: Slot) -> usize {
1910 let depth = self.heads.len();
1911 if slot != Slot::Body {
1912 self.open_head(slot == Slot::Applied);
1913 }
1914 depth
1915 }
1916
1917 fn open_head(&mut self, chain: bool) {
1920 let pats = self.b.pat_scratch.len();
1921 let chain = if chain {
1922 Some(self.scope.mark())
1923 } else {
1924 self.scope.push_level();
1925 None
1926 };
1927 self.heads.push(Head { pats, chain });
1928 }
1929
1930 fn param(
1934 &mut self,
1935 span: ChunkSpan,
1936 parse: impl FnOnce(&mut Self) -> Parsed<Pat>,
1937 ) -> Parsed<()> {
1938 self.param_spanned(|p| Ok((parse(p)?, span)))
1939 }
1940
1941 fn param_spanned(
1943 &mut self,
1944 parse: impl FnOnce(&mut Self) -> Parsed<(Pat, ChunkSpan)>,
1945 ) -> Parsed<()> {
1946 let head = self.heads.last().expect("a parameter has a head");
1947 if self.b.pat_scratch.len() - head.pats == MAX_HEAD {
1948 self.open_head(false);
1949 }
1950 let pat = parse(self)?;
1951 self.b.pat_scratch.push(pat);
1952 Ok(())
1953 }
1954
1955 fn end_abs(&mut self, depth: usize, body: Built, span: ChunkSpan) -> Parsed<Built> {
1959 let mut body = self.close(body);
1960 while self.heads.len() > depth {
1961 let head = self.heads.pop().expect("an open head");
1962 let plan = match head.chain {
1963 Some(mark) => {
1964 self.scope.truncate(mark);
1965 None
1966 }
1967 None => Some(self.scope.pop_level()),
1968 };
1969 body = (self.b.lambda(head.pats, body, plan.as_deref(), span), span);
1970 }
1971 Ok(Built::Node(body.0, body.1))
1972 }
1973
1974 fn guarded<'i, 'a>(
1979 &mut self,
1980 mut pat: (Pat, ChunkSpan),
1981 mut items: &'i [&'i Item<'a>],
1982 ) -> Parsed<((Pat, ChunkSpan), &'i [&'i Item<'a>])> {
1983 while !items.is_empty() && is_when_kw(items[0]) {
1984 let missing = Failure(
1986 ParseError::WhenMissingCond,
1987 self.src.items(&items[..items.len().min(2)]),
1988 );
1989 let (group, next): (&Seq<'a>, &[&Item<'a>]) = match items[0] {
1990 Item::Run(members) if members.len() == 2 => match &members[1] {
1991 Item::Parens(Group { seq, .. }) => (seq, &items[1..]),
1992 _ => return Err(missing),
1993 },
1994 Item::Run(_) => return Err(missing),
1995 _ => match items.get(1) {
1996 Some(Item::Parens(Group { seq, .. })) => (seq, &items[2..]),
1997 _ => return Err(missing),
1998 },
1999 };
2000 let Some(chain) = single_chain(group).filter(|chain| !chain.is_empty()) else {
2001 return Err(missing);
2002 };
2003 let inner = self.b.push_pat(pat.0, pat.1);
2004 let (gpat, cond) = if clause_is_binding(&chain) {
2005 let src = self.src;
2006 let (head, tail) =
2007 split_binding(&chain).map_err(|f| f.or_at(|| src.items(&chain)))?;
2008 let cond = self.expr(tail, Slot::Value)?;
2009 let cond = self.child(cond);
2010 let gpat = self.pattern(head)?;
2011 (self.b.push_pat(gpat, self.src.items(head)), cond)
2012 } else {
2013 let cond = self.expr(&chain, Slot::Value)?;
2014 (PatId::NONE, self.child(cond))
2015 };
2016 let guard = self.src.items(&items[..items.len() - next.len()]);
2017 pat = (Pat::When { inner, gpat, cond }, pat.1.join(guard));
2018 items = next;
2019 }
2020 Ok((pat, items))
2021 }
2022
2023 fn pattern(&mut self, items: &[&Item<'_>]) -> Parsed<Pat> {
2031 let src = self.src;
2032 self.or_pattern(items)
2033 .map_err(|f| f.or_at(|| src.items(items)))
2034 }
2035
2036 fn or_pattern(&mut self, items: &[&Item<'_>]) -> Parsed<Pat> {
2038 if items.is_empty() {
2039 return Err(ParseError::BadPattern.into());
2040 }
2041 if let Some(idx) = items.iter().position(|it| matches!(it, Item::Punct("|"))) {
2042 let mark = self.scope.mark();
2043 let left = self.pattern(&items[..idx])?;
2044 let left_names: Vec<Sym> = self.scope.bound_since(mark).to_vec();
2045 self.scope.truncate(mark);
2046 let right = self.pattern(&items[idx + 1..])?;
2047 if self.scope.bound_since(mark) != left_names.as_slice() {
2048 return Err(ParseError::OrBindersMismatch.into());
2049 }
2050 let left = self.b.push_pat(left, self.src.items(&items[..idx]));
2051 let right = self.b.push_pat(right, self.src.items(&items[idx + 1..]));
2052 return Ok(Pat::Or(left, right));
2053 }
2054 match items[0] {
2055 Item::Punct("<") => return Ok(Pat::Less(self.comparand(&items[1..])?)),
2056 Item::Punct(">") => return Ok(Pat::Greater(self.comparand(&items[1..])?)),
2057 _ => {}
2058 }
2059 if let Some(idx) = items.iter().position(|it| matches!(it, Item::Punct("="))) {
2060 if idx == 0 {
2061 return Ok(Pat::Equal(self.comparand(&items[1..])?));
2062 }
2063 let name = plain_name(&items[..idx], ParseError::BadPattern, self.ctx, self.src)?;
2064 self.scope.bind(name)?;
2065 let inner = self.pattern(&items[idx + 1..])?;
2066 let span = self.src.items(&items[idx + 1..]);
2067 return Ok(Pat::At(name, self.b.push_pat(inner, span)));
2068 }
2069 self.narrowed(items)
2070 }
2071
2072 fn comparand(&mut self, items: &[&Item<'_>]) -> Parsed<NodeId> {
2075 let node = match items {
2076 [it] => match it {
2077 Item::Sym(s) => self.sym(s)?,
2078 Item::Prefixed { sigil: '.', item } => self.dot_symbol(item)?,
2079 Item::Str(s) => self.b.str(decode_str(s)?),
2080 Item::Run(members) => {
2081 let head = check_path(members, self.ctx)?;
2082 self.path(head, members)?.0
2083 }
2084 _ => return Err(Failure(ParseError::ComparandNotAtom, self.src.items(items))),
2085 },
2086 _ => return Err(Failure(ParseError::ComparandNotAtom, self.src.items(items))),
2087 };
2088 Ok(self.b.push(node, self.src.items(items)))
2089 }
2090
2091 fn narrowed(&mut self, items: &[&Item<'_>]) -> Parsed<Pat> {
2094 if let Item::Sym("Self") = items[0] {
2095 if items.len() < 2 {
2096 return Err(ParseError::BadPattern.into());
2097 }
2098 let depth = self
2099 .scope
2100 .home_depth()
2101 .ok_or_else(|| ParseError::OutsideModule(text("Self")))?;
2102 let inner = self.pattern(&items[1..])?;
2103 return Ok(Pat::Unwrap {
2104 depth,
2105 inner: self.b.push_pat(inner, self.src.items(&items[1..])),
2106 });
2107 }
2108 if let Item::Parens(Group { seq, .. }) = items[0] {
2109 if let Some(chain) = single_chain(seq) {
2110 if !chain.is_empty() && matches!(chain[0], Item::Sym("as")) {
2111 let proto = self.proto(&chain[1..])?;
2112 let inner = self.pattern(&items[1..])?;
2113 return Ok(self.typed(proto, (inner, self.src.items(&items[1..]))));
2114 }
2115 }
2116 }
2117 if let Some(idx) = items.iter().position(|it| matches!(it, Item::Sym("as"))) {
2118 let proto = self.proto(&items[idx + 1..])?;
2119 let inner = self.atom(&items[..idx])?;
2120 return Ok(self.typed(proto, (inner, self.src.items(&items[..idx]))));
2121 }
2122 self.atom(items)
2123 }
2124
2125 fn proto(&mut self, items: &[&Item<'_>]) -> Parsed<Proto> {
2128 let src = self.src;
2129 self.proto_ref(items)
2130 .map_err(|f| f.or_at(|| src.items(items)))
2131 }
2132
2133 fn proto_ref(&mut self, items: &[&Item<'_>]) -> Parsed<Proto> {
2135 let node = match items {
2136 [Item::Sym(s)] => match classify(s, self.ctx)? {
2137 SymRef::Int(_) => return Err(ParseError::UnknownType.into()),
2138 r => self.resolve_sym(r)?,
2139 },
2140 [Item::Run(members)] => {
2141 let head = check_path(members, self.ctx)?;
2142 self.path(head, members)?.0
2143 }
2144 _ => return Err(ParseError::UnknownType.into()),
2145 };
2146 match node {
2147 Node::Builtin(op) => match op.proto_kind() {
2148 Some(kind) => Ok(Proto::Kind(kind)),
2149 None => Err(ParseError::NotAPrototype(text(op.name())).into()),
2150 },
2151 node => Ok(Proto::Ref(self.b.push(node, self.src.items(items)))),
2152 }
2153 }
2154
2155 fn typed(&mut self, proto: Proto, inner: (Pat, ChunkSpan)) -> Pat {
2157 let inner = self.b.push_pat(inner.0, inner.1);
2158 match proto {
2159 Proto::Kind(kind) => Pat::TypeKind(kind, inner),
2160 Proto::Ref(node) => Pat::TypeRef(node, inner),
2161 }
2162 }
2163
2164 fn path(&mut self, head: SymRef, members: &[Item<'_>]) -> Parsed<Spanned> {
2169 let mut acc = (self.resolve_sym(head)?, self.src.item(&members[0]));
2170 for m in &members[1..] {
2171 let Item::Prefixed { sigil: '.', item } = m else {
2172 unreachable!("checked by check_path")
2173 };
2174 let symbol = self.dot_symbol(item)?;
2175 let Node::Symbol(name) = symbol else {
2176 unreachable!("a dotted segment is a symbol")
2177 };
2178 let span = self.src.item(m);
2179 if let Some(op) = builtin_of(acc.0).and_then(|ns| ns.member(name)) {
2180 acc = (Node::Builtin(op), acc.1.join(span));
2181 continue;
2182 }
2183 let mark = self.b.scratch.len();
2184 let joined = acc.1.join(span);
2185 self.b.scratch.push(acc);
2186 self.b.scratch.push((symbol, span));
2187 let app = Node::App {
2188 len: 2,
2189 args: self.b.push_run(Run::App, mark),
2190 };
2191 acc = (app, joined);
2192 }
2193 Ok(acc)
2194 }
2195
2196 fn atom(&mut self, items: &[&Item<'_>]) -> Parsed<Pat> {
2198 match items {
2199 [it] => self.atom_item(it),
2200 _ => Err(ParseError::BadPattern.into()),
2201 }
2202 }
2203
2204 fn atom_item(&mut self, item: &Item<'_>) -> Parsed<Pat> {
2206 let src = self.src;
2207 self.atom_pattern(item)
2208 .map_err(|f| f.or_at(|| src.item(item)))
2209 }
2210
2211 fn atom_pattern(&mut self, item: &Item<'_>) -> Parsed<Pat> {
2213 match item {
2214 Item::Sym("_") => Ok(Pat::Discard),
2215 Item::Sym(s) if is_keyword(s) => Err(ParseError::ReservedKeyword.into()),
2216 Item::Sym(s) if s.starts_with("__") => Err(ParseError::ReservedName.into()),
2217 Item::Sym(s) => match parse_int(s) {
2218 Some(n) => {
2219 let node = self.b.int(n);
2220 Ok(Pat::Equal(self.b.push(node, self.src.item(item))))
2221 }
2222 None if s.as_bytes()[0].is_ascii_digit() => Err(ParseError::MalformedNumber.into()),
2223 None => {
2224 let name = self.ctx.intern(s);
2225 self.scope.bind(name)?;
2226 Ok(Pat::Bind(name))
2227 }
2228 },
2229 Item::Prefixed {
2230 sigil: '.',
2231 item: inner,
2232 } => {
2233 let node = self.dot_symbol(inner)?;
2234 Ok(Pat::Equal(self.b.push(node, self.src.item(item))))
2235 }
2236 Item::Str(s) => {
2237 let node = self.b.str(decode_str(s)?);
2238 Ok(Pat::Equal(self.b.push(node, self.src.item(item))))
2239 }
2240 Item::Brackets(_) => Err(ParseError::BareListLiteral.into()),
2241 Item::Parens(Group { seq, .. }) => match single_chain(seq) {
2242 Some(chain) if !chain.is_empty() => self.pattern(&chain),
2243 _ => Err(ParseError::BadPattern.into()),
2244 },
2245 Item::Braces(_) => Err(ParseError::BareMapLiteral.into()),
2246 Item::Prefixed { sigil: '#', item } => match item.as_ref() {
2247 Item::Brackets(Group { seq, .. }) => self.list_pattern(seq),
2248 Item::Braces(Group { seq, .. }) => self.map_pattern(seq),
2249 _ => Err(ParseError::ReservedLiteralForm.into()),
2250 },
2251 _ => Err(ParseError::BadPattern.into()),
2252 }
2253 }
2254
2255 fn rest(&mut self, rest: Option<&str>, span: ChunkSpan) -> Parsed<PatId> {
2257 let pat = match rest {
2258 Some(name) => {
2259 let name = self.ctx.intern(name);
2260 self.scope.bind(name)?;
2261 Pat::Bind(name)
2262 }
2263 None => Pat::Discard,
2264 };
2265 Ok(self.b.push_pat(pat, span))
2266 }
2267
2268 fn list_pattern(&mut self, seq: &Seq<'_>) -> Parsed<Pat> {
2271 let chains = chain_slices(seq);
2272 let (elems, rest) = split_rest(&chains)?;
2273 let rest = match rest {
2274 Some(rest) => self.rest(rest, self.rest_span(&chains))?,
2275 None => PatId::NONE,
2276 };
2277 let mark = self.b.pat_scratch.len();
2278 for chain in elems {
2279 let pat = self.pattern(chain)?;
2280 self.b.pat_scratch.push((pat, self.src.items(chain)));
2281 }
2282 Ok(Pat::List {
2283 len: len32(elems.len()),
2284 elems: self.b.push_pat_run(Run::PatList, mark),
2285 rest,
2286 })
2287 }
2288
2289 fn map_pattern(&mut self, seq: &Seq<'_>) -> Parsed<Pat> {
2295 let chains = chain_slices(seq);
2296 let (entries, rest) = split_rest(&chains)?;
2297 let mut keys = Vec::with_capacity(entries.len());
2298 for chain in entries {
2299 let malformed = || Failure(ParseError::MalformedMapKey, self.src.items(chain));
2300 let colon = chain
2301 .iter()
2302 .position(|it| matches!(it, Item::Punct(":")))
2303 .ok_or_else(malformed)?;
2304 if colon == 0 || colon + 1 == chain.len() {
2305 return Err(malformed());
2306 }
2307 let key = match &chain[..colon] {
2308 [Item::Sym(s)] if s.as_bytes()[0].is_ascii_digit() => return Err(malformed()),
2309 [Item::Sym(_)] | [Item::Run(_)] => true,
2310 key => is_lookup(key),
2311 };
2312 keys.push((colon, key));
2313 }
2314 let n = entries.len();
2315 let mark = self.b.pat_scratch.len();
2316 self.b
2317 .pat_scratch
2318 .resize(mark + 2 * n, (Pat::None, ChunkSpan::NONE));
2319 for (i, (chain, &(colon, lookup))) in entries.iter().zip(&keys).enumerate() {
2320 if lookup {
2321 let node = match &chain[..colon] {
2322 [Item::Sym(s)] => Node::Symbol(self.ctx.intern(s)),
2323 [Item::Run(members)] => {
2324 let head = check_path(members, self.ctx)?;
2325 self.path(head, members)?.0
2326 }
2327 key => self.lookup_expr(key)?,
2328 };
2329 let span = self.src.items(&chain[..colon]);
2330 self.b.pat_scratch[mark + i] = (Pat::Lookup(self.b.push(node, span)), span);
2331 }
2332 }
2333 for (i, (chain, &(colon, lookup))) in entries.iter().zip(&keys).enumerate() {
2334 if lookup {
2335 let value = self.pattern(&chain[colon + 1..])?;
2336 let span = self.src.items(&chain[colon + 1..]);
2337 self.b.pat_scratch[mark + n + i] = (value, span);
2338 }
2339 }
2340 for (i, (chain, &(colon, lookup))) in entries.iter().zip(&keys).enumerate() {
2341 if !lookup {
2342 let key = self.pattern(&chain[..colon])?;
2343 self.b.pat_scratch[mark + i] = (key, self.src.items(&chain[..colon]));
2344 let value = self.pattern(&chain[colon + 1..])?;
2345 let span = self.src.items(&chain[colon + 1..]);
2346 self.b.pat_scratch[mark + n + i] = (value, span);
2347 }
2348 }
2349 let rest = match rest {
2350 Some(rest) => self.rest(rest, self.rest_span(&chains))?,
2351 None => PatId::NONE,
2352 };
2353 Ok(Pat::Map {
2354 len: len32(n),
2355 entries: self.b.push_pat_run(Run::PatMap, mark),
2356 rest,
2357 })
2358 }
2359
2360 fn rest_span(&self, chains: &[Vec<&Item<'_>>]) -> ChunkSpan {
2362 chains
2363 .last()
2364 .map_or(ChunkSpan::NONE, |chain| self.src.items(chain))
2365 }
2366
2367 fn lookup_expr(&mut self, items: &[&Item<'_>]) -> Parsed<Node> {
2369 if let Some(Item::Punct("=")) = items.first() {
2370 let node = self.comparand(&items[1..])?;
2371 return Ok(self.b.node(node).0);
2372 }
2373 match items {
2374 [Item::Parens(Group { seq, .. })] => {
2375 let chain = single_chain(seq).expect("checked by is_lookup");
2376 self.lookup_expr(&chain)
2377 }
2378 [Item::Sym(s)] => Ok(self.b.int(parse_int(s).expect("checked by is_lookup"))),
2379 [Item::Prefixed { sigil: '.', item }] => self.dot_symbol(item),
2380 [Item::Str(s)] => Ok(self.b.str(decode_str(s)?)),
2381 _ => unreachable!("checked by is_lookup"),
2382 }
2383 }
2384}
2385
2386enum Proto {
2388 Kind(crate::builtins::TyKind),
2390 Ref(NodeId),
2392}
2393
2394fn builtin_of(node: Node) -> Option<Builtin> {
2396 match node {
2397 Node::Builtin(op) => Some(op),
2398 _ => None,
2399 }
2400}
2401
2402fn classify(s: &str, ctx: &Ctx) -> Parsed<SymRef> {
2405 if s == "Self" {
2406 return Ok(SymRef::Home);
2407 }
2408 if is_keyword(s) {
2409 return Err(ParseError::ReservedKeyword.into());
2410 }
2411 if s == "_" {
2412 Err(ParseError::DiscardReference.into())
2413 } else if let Some(n) = parse_int(s) {
2414 Ok(SymRef::Int(n))
2415 } else if s.as_bytes()[0].is_ascii_digit() {
2416 Err(ParseError::MalformedNumber.into())
2417 } else if s.starts_with("__") {
2418 match Builtin::from_name(s) {
2419 Some(op) => Ok(SymRef::Builtin(op)),
2420 None => Err(ParseError::UnknownReserved(text(s)).into()),
2421 }
2422 } else {
2423 Ok(SymRef::Name(ctx.intern(s)))
2424 }
2425}
2426
2427fn check_path(members: &[Item<'_>], ctx: &Ctx) -> Parsed<SymRef> {
2430 if members.len() < 2 {
2431 return Err(ParseError::ComparandNotAtom.into());
2432 }
2433 let head = match &members[0] {
2434 Item::Sym(s) => classify(s, ctx)?,
2435 _ => return Err(ParseError::ComparandNotAtom.into()),
2436 };
2437 for m in &members[1..] {
2438 if !matches!(m, Item::Prefixed { sigil: '.', .. }) {
2439 return Err(ParseError::ComparandNotAtom.into());
2440 }
2441 }
2442 for m in &members[1..] {
2443 if let Item::Prefixed { item, .. } = m {
2444 if !matches!(item.as_ref(), Item::Sym(_)) {
2445 return Err(ParseError::BadSymbol.into());
2446 }
2447 }
2448 }
2449 Ok(head)
2450}
2451
2452fn is_lookup(items: &[&Item<'_>]) -> bool {
2455 if items.is_empty() || items.iter().any(|it| matches!(it, Item::Punct("|"))) {
2456 return false;
2457 }
2458 if matches!(items[0], Item::Punct("<") | Item::Punct(">")) {
2459 return false;
2460 }
2461 if let Some(idx) = items.iter().position(|it| matches!(it, Item::Punct("="))) {
2462 return idx == 0;
2463 }
2464 if matches!(items[0], Item::Sym("Self")) || items.iter().any(|it| matches!(it, Item::Sym("as")))
2465 {
2466 return false;
2467 }
2468 match items {
2469 [Item::Sym(s)] => !is_keyword(s) && !s.starts_with("__") && parse_int(s).is_some(),
2470 [Item::Prefixed { sigil: '.', .. }] | [Item::Str(_)] => true,
2471 [Item::Parens(Group { seq, .. })] => match single_chain(seq) {
2472 Some(chain) => is_lookup(&chain) && !starts_with_as(&chain),
2473 None => false,
2474 },
2475 _ => false,
2476 }
2477}
2478
2479fn starts_with_as(chain: &[&Item<'_>]) -> bool {
2481 matches!(chain.first(), Some(Item::Sym("as")))
2482}
2483
2484#[allow(clippy::type_complexity)]
2488fn split_rest<'c, 'b, 'a>(
2489 chains: &'c [Vec<&'b Item<'a>>],
2490) -> Parsed<(&'c [Vec<&'b Item<'a>>], Option<Option<&'a str>>)> {
2491 let n = chains.len();
2492 for (i, chain) in chains.iter().enumerate() {
2493 if as_rest(chain).is_some() && i != n - 1 {
2494 return Err(ParseError::BadPattern.into());
2495 }
2496 }
2497 match chains.split_last() {
2498 Some((last, entries)) => match as_rest(last) {
2499 Some(rest) => Ok((entries, Some(rest))),
2500 None => Ok((chains, None)),
2501 },
2502 None => Ok((chains, None)),
2503 }
2504}
2505
2506fn as_rest<'a>(chain: &[&Item<'a>]) -> Option<Option<&'a str>> {
2508 let [Item::Prefixed {
2509 sigil: '.',
2510 item: a,
2511 }] = chain
2512 else {
2513 return None;
2514 };
2515 let Item::Prefixed {
2516 sigil: '.',
2517 item: b,
2518 } = a.as_ref()
2519 else {
2520 return None;
2521 };
2522 match b.as_ref() {
2523 Item::Prefixed {
2524 sigil: '.',
2525 item: c,
2526 } => match c.as_ref() {
2527 Item::Sym(name) => Some(Some(name)),
2528 _ => None,
2529 },
2530 Item::Punct(".") => Some(None),
2531 _ => None,
2532 }
2533}
2534
2535#[allow(clippy::type_complexity)]
2538fn split_binding<'i, 'a>(
2539 items: &'i [&'i Item<'a>],
2540) -> Parsed<(&'i [&'i Item<'a>], &'i [&'i Item<'a>])> {
2541 let mut eq = None;
2542 for (i, it) in items.iter().enumerate() {
2543 if matches!(it, Item::Punct("=")) {
2544 if eq.is_some() {
2545 return Err(ParseError::MalformedBinding.into());
2546 }
2547 eq = Some(i);
2548 }
2549 }
2550 let eq = eq.ok_or(ParseError::MalformedBinding)?;
2551 let (head, tail) = (&items[..eq], &items[eq + 1..]);
2552 if head.is_empty() || tail.is_empty() {
2553 return Err(ParseError::MalformedBinding.into());
2554 }
2555 if head.iter().any(|it| matches!(it, Item::Punct("|"))) {
2556 return Err(ParseError::LetOrUnparenthesized.into());
2557 }
2558 if let [it] = head {
2559 if is_bare_literal_header(it) {
2560 return Err(ParseError::BareLiteralHeader.into());
2561 }
2562 }
2563 Ok((head, tail))
2564}
2565
2566fn check_run_head(members: &[Item<'_>]) -> Parsed<()> {
2568 if matches!(&members[0], Item::Prefixed { sigil: '&', .. }) {
2569 return Err(ParseError::BinderRunGlued.into());
2570 }
2571 if let (
2572 Item::Sym(head),
2573 Some(Item::Prefixed {
2574 sigil: '.',
2575 item: seg,
2576 }),
2577 ) = (&members[0], members.get(1))
2578 {
2579 if parse_int(head).is_some() && is_dot_number(seg) {
2580 return Err(ParseError::FloatLiteralUnsupported.into());
2581 }
2582 }
2583 Ok(())
2584}
2585
2586fn is_dot_number(item: &Item<'_>) -> bool {
2588 match item {
2589 Item::Sym(s) => parse_int(s).is_some(),
2590 _ => false,
2591 }
2592}
2593
2594fn is_self_head(members: &[Item<'_>]) -> bool {
2596 matches!(
2597 members.first(),
2598 Some(Item::Prefixed { sigil: '#', item })
2599 if matches!(item.as_ref(), Item::Sym("Self"))
2600 )
2601}
2602
2603fn decode_str(raw: &str) -> Parsed<Text> {
2606 let b = raw.as_bytes();
2607 let mut out = alloc::string::String::with_capacity(raw.len());
2608 let mut i = 0;
2609 let mut chunk = 0;
2610 while i < b.len() {
2611 if b[i] != b'\\' {
2612 i += 1;
2613 continue;
2614 }
2615 out.push_str(&raw[chunk..i]);
2616 match b[i + 1] {
2617 b'"' => out.push('"'),
2618 b'\\' => out.push('\\'),
2619 b'/' => out.push('/'),
2620 b'n' => out.push('\n'),
2621 b't' => out.push('\t'),
2622 b'r' => out.push('\r'),
2623 b'b' => out.push('\u{8}'),
2624 b'f' => out.push('\u{c}'),
2625 b'u' => {
2626 let hi = hex4(&b[i + 2..i + 6]);
2627 i += 6;
2628 if (0xD800..=0xDBFF).contains(&hi) {
2629 let lo = match (b.get(i), b.get(i + 1)) {
2630 (Some(b'\\'), Some(b'u')) => hex4(&b[i + 2..i + 6]),
2631 _ => return Err(ParseError::LoneSurrogate.into()),
2632 };
2633 if !(0xDC00..=0xDFFF).contains(&lo) {
2634 return Err(ParseError::LoneSurrogate.into());
2635 }
2636 let c = 0x1_0000 + ((hi - 0xD800) << 10) + (lo - 0xDC00);
2637 out.push(char::from_u32(c).expect("combined surrogate pair"));
2638 i += 6;
2639 } else if (0xDC00..=0xDFFF).contains(&hi) {
2640 return Err(ParseError::LoneSurrogate.into());
2641 } else {
2642 out.push(char::from_u32(hi).expect("non-surrogate BMP scalar"));
2643 }
2644 chunk = i;
2645 continue;
2646 }
2647 _ => unreachable!("Muon validated the <str> escape grammar"),
2648 }
2649 i += 2;
2650 chunk = i;
2651 }
2652 out.push_str(&raw[chunk..]);
2653 Ok(Text::from(out.as_str()))
2654}
2655
2656fn hex4(b: &[u8]) -> u32 {
2658 b.iter()
2659 .fold(0, |v, &c| v * 16 + (c as char).to_digit(16).unwrap())
2660}
2661
2662pub(crate) fn parse_int(s: &str) -> Option<BigInt> {
2664 let (neg, body) = match s.as_bytes().first()? {
2665 b'-' => (true, &s[1..]),
2666 b'+' => (false, &s[1..]),
2667 _ => (false, s),
2668 };
2669 let (radix, digits) =
2670 if let Some(h) = body.strip_prefix("0x").or_else(|| body.strip_prefix("0X")) {
2671 (16u32, h)
2672 } else if let Some(b) = body.strip_prefix("0b").or_else(|| body.strip_prefix("0B")) {
2673 (2, b)
2674 } else {
2675 (10, body)
2676 };
2677 let mut cleaned = alloc::string::String::new();
2678 let mut after_sep = true;
2679 for &c in digits.as_bytes() {
2680 if c == b'_' {
2681 if after_sep {
2682 return None;
2683 }
2684 after_sep = true;
2685 } else {
2686 cleaned.push(c as char);
2687 after_sep = false;
2688 }
2689 }
2690 if after_sep || cleaned.is_empty() {
2691 return None;
2692 }
2693 let mag = BigInt::parse_bytes(cleaned.as_bytes(), radix)?;
2694 Some(if neg { -mag } else { mag })
2695}
2696
2697fn clause_is_binding(items: &[&Item<'_>]) -> bool {
2702 items.iter().any(|it| matches!(it, Item::Punct("=")))
2703}
2704
2705fn is_bare_literal_header(item: &Item<'_>) -> bool {
2711 match item {
2712 Item::Sym(s) => parse_int(s).is_some(),
2713 Item::Prefixed { sigil: '.', .. } => true,
2714 Item::Str(_) => true,
2715 _ => false,
2716 }
2717}
2718
2719fn is_when_kw(item: &Item) -> bool {
2721 head_keyword(item) == Some("when")
2722}
2723
2724fn chain_slices<'a, 'b>(seq: &'b Seq<'a>) -> Vec<Vec<&'b Item<'a>>> {
2726 let chains = seq
2727 .0
2728 .iter()
2729 .filter(|c| !is_comment_only(c))
2730 .map(|c| {
2731 c.0.iter()
2732 .filter(|it| !matches!(it, Item::Comm(_)))
2733 .collect()
2734 })
2735 .collect();
2736 join_chains(chains)
2737}
2738
2739fn braces_contain_colon(seq: &Seq<'_>) -> bool {
2742 for chain in seq.0.iter().filter(|c| !is_comment_only(c)) {
2743 let items: Vec<&Item<'_>> = chain
2744 .0
2745 .iter()
2746 .filter(|it| !matches!(it, Item::Comm(_)))
2747 .collect();
2748 if items.len() >= 2 && matches!(items[1], Item::Punct(":")) {
2749 return true;
2750 }
2751 }
2752 false
2753}
2754
2755fn join_chains<'a, 'b>(chains: Vec<Vec<&'b Item<'a>>>) -> Vec<Vec<&'b Item<'a>>> {
2759 let mut out: Vec<Vec<&'b Item<'a>>> = Vec::with_capacity(chains.len());
2760 for chain in chains {
2761 let join = matches!(out.last(), Some(prev) if trailing_join(prev) || leading_join(&chain));
2762 if join {
2763 out.last_mut().unwrap().extend(chain);
2764 } else {
2765 out.push(chain);
2766 }
2767 }
2768 out
2769}
2770
2771fn trailing_join(chain: &[&Item]) -> bool {
2773 match chain.last() {
2774 Some(Item::Prefixed { sigil: '&', .. }) => true,
2775 Some(Item::Punct("=")) | Some(Item::Punct("|>")) => true,
2776 _ => {
2777 let n = chain.len();
2778 n >= 2
2779 && matches!(chain[n - 2], Item::Sym("when"))
2780 && matches!(chain[n - 1], Item::Parens(_))
2781 }
2782 }
2783}
2784
2785fn leading_join(chain: &[&Item]) -> bool {
2787 match chain.first() {
2788 Some(Item::Punct("|>")) => true,
2789 Some(first) => matches!(head_keyword(first), Some("elif" | "else" | "catch")),
2790 None => false,
2791 }
2792}
2793
2794fn single_chain<'a, 'b>(seq: &'b Seq<'a>) -> Option<Vec<&'b Item<'a>>> {
2796 let mut chains = chain_slices(seq).into_iter();
2797 let first = chains.next()?;
2798 if chains.next().is_some() {
2799 return None;
2800 }
2801 Some(first)
2802}
2803
2804fn is_comment_only(chain: &Chain) -> bool {
2806 chain.0.iter().all(|it| matches!(it, Item::Comm(_)))
2807}
2808
2809fn is_keyword(s: &str) -> bool {
2811 matches!(
2812 s,
2813 "Self"
2814 | "let"
2815 | "recur"
2816 | "import"
2817 | "const"
2818 | "local"
2819 | "with"
2820 | "as"
2821 | "when"
2822 | "match"
2823 | "case"
2824 | "of"
2825 | "if"
2826 | "elif"
2827 | "else"
2828 | "catch"
2829 )
2830}
2831
2832pub fn is_bindable_name(name: &str) -> bool {
2834 muon::is_sym(name)
2835 && !is_keyword(name)
2836 && !name.starts_with("__")
2837 && name != "_"
2838 && !reads_as_number(name)
2839}
2840
2841fn is_split_point(item: &Item) -> bool {
2843 is_binder(item)
2844 || matches!(
2845 head_keyword(item),
2846 Some("let") | Some("recur") | Some("case")
2847 )
2848}
2849
2850fn is_binder(item: &Item) -> bool {
2852 matches!(item, Item::Prefixed { sigil: '&', .. })
2853}
2854
2855fn head_keyword<'a>(item: &Item<'a>) -> Option<&'a str> {
2857 match item {
2858 Item::Sym(s) if is_keyword(s) => Some(s),
2859 Item::Run(members) => match members.first() {
2860 Some(Item::Sym(s)) if is_keyword(s) => Some(s),
2861 _ => None,
2862 },
2863 _ => None,
2864 }
2865}