refactor: migrate chumsky 0.9.3 -> 0.13.0

Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-chumsky = "0.9.3"
+chumsky = "0.13"
 itertools = "0.13.0"
 serde = { version = "1.0.203", features = ["derive"] }
 textwrap = "0.16.1"

benches/parser_benchmarks.rs

@@ -43,10 +43,10 @@ fn stage_1_bench(c: &mut Criterion) {
 fn stage_2_bench(c: &mut Criterion) {
     let mut group = c.benchmark_group("stage_2");
     for (name, input) in [("small", SMALL), ("medium", MEDIUM), ("large", LARGE)] {
-        let tokens = stage_1().parse(input).unwrap();
+        let tokens = stage_1().parse(input).into_result().unwrap();
         group.throughput(Throughput::Elements(tokens.len() as u64));
         group.bench_with_input(BenchmarkId::from_parameter(name), &tokens, |b, tokens| {
-            b.iter(|| stage_2().parse(black_box(tokens.clone())).unwrap())
+            b.iter(|| stage_2().parse(black_box(tokens.as_slice())).into_result().unwrap())
         });
     }
     group.finish();
@@ -55,11 +55,11 @@ fn stage_2_bench(c: &mut Criterion) {
 fn stage_3_bench(c: &mut Criterion) {
     let mut group = c.benchmark_group("stage_3");
     for (name, input) in [("small", SMALL), ("medium", MEDIUM), ("large", LARGE)] {
-        let tokens = stage_1().parse(input).unwrap();
-        let blocks = stage_2().parse(tokens).unwrap();
+        let tokens = stage_1().parse(input).into_result().unwrap();
+        let blocks = stage_2().parse(tokens.as_slice()).into_result().unwrap();
         group.throughput(Throughput::Elements(blocks.len() as u64));
         group.bench_with_input(BenchmarkId::from_parameter(name), &blocks, |b, blocks| {
-            b.iter(|| stage_3().parse(black_box(blocks.clone())).unwrap())
+            b.iter(|| stage_3().parse(black_box(blocks.as_slice())).into_result().unwrap())
         });
     }
     group.finish();
@@ -79,7 +79,7 @@ fn stage_4_bench(c: &mut Criterion) {
 
 criterion_group!(
     name = benches;
-    config = Criterion::default().sample_size(50);
+    config = Criterion::default();
     targets = parse_tree_bench,
         parse_flat_bench,
         stage_1_bench,

src/error.rs

@@ -1,43 +1,36 @@
-use chumsky::error::Simple;
+use chumsky::error::Rich;
 
-use crate::{stage_1::NorgToken, stage_2::NorgBlock, NorgASTFlat};
+use crate::{stage_1::NorgToken, stage_2::NorgBlock};
 
 /// Represents errors that can occur during the parsing process across different stages.
 #[derive(Debug)]
 pub enum NorgParseError {
-    Stage1(Vec<Simple<char>>),
-    Stage2(Vec<Simple<NorgToken>>),
-    Stage3(Vec<Simple<NorgBlock>>),
-    Stage4(Vec<Simple<NorgASTFlat>>),
-    Meta(Simple<char>),
+    Stage1(Vec<Rich<'static, char>>),
+    Stage2(Vec<Rich<'static, NorgToken>>),
+    Stage3(Vec<Rich<'static, NorgBlock>>),
+    Meta(Rich<'static, char>),
 }
 
-impl From<Vec<Simple<char>>> for NorgParseError {
-    fn from(error: Vec<Simple<char>>) -> Self {
+impl From<Vec<Rich<'static, char>>> for NorgParseError {
+    fn from(error: Vec<Rich<'static, char>>) -> Self {
         NorgParseError::Stage1(error)
     }
 }
 
-impl From<Vec<Simple<NorgToken>>> for NorgParseError {
-    fn from(error: Vec<Simple<NorgToken>>) -> Self {
+impl From<Vec<Rich<'static, NorgToken>>> for NorgParseError {
+    fn from(error: Vec<Rich<'static, NorgToken>>) -> Self {
         NorgParseError::Stage2(error)
     }
 }
 
-impl From<Vec<Simple<NorgBlock>>> for NorgParseError {
-    fn from(error: Vec<Simple<NorgBlock>>) -> Self {
+impl From<Vec<Rich<'static, NorgBlock>>> for NorgParseError {
+    fn from(error: Vec<Rich<'static, NorgBlock>>) -> Self {
         NorgParseError::Stage3(error)
     }
 }
 
-impl From<Vec<Simple<NorgASTFlat>>> for NorgParseError {
-    fn from(error: Vec<Simple<NorgASTFlat>>) -> Self {
-        NorgParseError::Stage4(error)
-    }
-}
-
-impl From<Simple<char>> for NorgParseError {
-    fn from(error: Simple<char>) -> Self {
+impl From<Rich<'static, char>> for NorgParseError {
+    fn from(error: Rich<'static, char>) -> Self {
         NorgParseError::Meta(error)
     }
-}
+}