Remove unnecessary unsafe functions

Fundamentally, pest never does anything unsafe. All of the UTF-8 slicing uses indexing and is therefore checked. There's no need to provide the internal guarantee that all pest positions lie on UTF-8 boundaries when it provides no performance benefit.
pest-parser · Mar 21, 2024 · 8c350a5 · 8c350a5
1 parent 9f9094e
commit 8c350a5
Show file tree

Hide file tree

Showing 10 changed files with 170 additions and 258 deletions.
diff --git a/debugger/src/lib.rs b/debugger/src/lib.rs
@@ -346,7 +346,7 @@ impl DebuggerContext {
     /// Returns a `Position` from the loaded input.
     pub fn get_position(&self, pos: usize) -> Result<Position<'_>, DebuggerError> {
         match self.input {
-            Some(ref input) => Position::new(input, pos).ok_or(DebuggerError::InvalidPosition(pos)),
+            Some(ref input) => Ok(Position::new(input, pos)),
             None => Err(DebuggerError::InputNotOpened),
         }
     }

diff --git a/meta/src/validator.rs b/meta/src/validator.rs
@@ -769,15 +769,15 @@ mod tests {
         assert!(is_non_progressing(
             &ParserExpr::PosPred(Box::new(ParserNode {
                 expr: progressing.clone(),
-                span: Span::new(" ", 0, 1).unwrap(),
+                span: Span::new(" ", 0, 1),
             })),
             &HashMap::new(),
             &mut Vec::new()
         ));
         assert!(is_non_progressing(
             &ParserExpr::NegPred(Box::new(ParserNode {
                 expr: progressing,
-                span: Span::new(" ", 0, 1).unwrap(),
+                span: Span::new(" ", 0, 1),
             })),
             &HashMap::new(),
             &mut Vec::new()
@@ -788,7 +788,7 @@ mod tests {
     fn non_progressing_0_length_repetitions() {
         let input_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("A".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(!is_non_progressing(
@@ -840,7 +840,7 @@ mod tests {
         let a = "";
         let non_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Str(a.into()),
-            span: Span::new(a, 0, 0).unwrap(),
+            span: Span::new(a, 0, 0),
         });
         let exact = ParserExpr::RepExact(non_progressing_node.clone(), 7);
         let min = ParserExpr::RepMin(non_progressing_node.clone(), 23);
@@ -866,7 +866,7 @@ mod tests {
         let a = "A";
         let input_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Str(a.into()),
-            span: Span::new(a, 0, 1).unwrap(),
+            span: Span::new(a, 0, 1),
         });
         let exact = ParserExpr::RepExact(input_progressing_node.clone(), 1);
         let min = ParserExpr::RepMin(input_progressing_node.clone(), 2);
@@ -896,7 +896,7 @@ mod tests {
         let a = "";
         let non_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Str(a.into()),
-            span: Span::new(a, 0, 0).unwrap(),
+            span: Span::new(a, 0, 0),
         });
         let push = ParserExpr::Push(non_progressing_node.clone());
 
@@ -908,7 +908,7 @@ mod tests {
         let a = "i'm make progress";
         let progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Str(a.into()),
-            span: Span::new(a, 0, 1).unwrap(),
+            span: Span::new(a, 0, 1),
         });
         let push = ParserExpr::Push(progressing_node.clone());
 
@@ -919,7 +919,7 @@ mod tests {
     fn node_tag_forwards_is_non_progressing() {
         let progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("i'm make progress".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
         assert!(!is_non_progressing(
             &progressing_node.clone().expr,
@@ -928,7 +928,7 @@ mod tests {
         ));
         let non_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
         assert!(is_non_progressing(
             &non_progressing_node.clone().expr,
@@ -974,7 +974,7 @@ mod tests {
     fn progressing_choice() {
         let left_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("i'm make progress".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
         assert!(!is_non_progressing(
             &left_progressing_node.clone().expr,
@@ -984,7 +984,7 @@ mod tests {
 
         let right_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Ident("DROP".into()),
-            span: Span::new("DROP", 0, 3).unwrap(),
+            span: Span::new("DROP", 0, 3),
         });
 
         assert!(!is_non_progressing(
@@ -998,7 +998,7 @@ mod tests {
     fn non_progressing_choices() {
         let left_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("i'm make progress".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(!is_non_progressing(
@@ -1009,7 +1009,7 @@ mod tests {
 
         let left_non_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(is_non_progressing(
@@ -1020,7 +1020,7 @@ mod tests {
 
         let right_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Ident("DROP".into()),
-            span: Span::new("DROP", 0, 3).unwrap(),
+            span: Span::new("DROP", 0, 3),
         });
 
         assert!(!is_non_progressing(
@@ -1032,9 +1032,9 @@ mod tests {
         let right_non_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Opt(Box::new(ParserNode {
                 expr: ParserExpr::Str("   ".into()),
-                span: Span::new(" ", 0, 1).unwrap(),
+                span: Span::new(" ", 0, 1),
             })),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(is_non_progressing(
@@ -1064,15 +1064,15 @@ mod tests {
     fn non_progressing_seq() {
         let left_non_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         let right_non_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Opt(Box::new(ParserNode {
                 expr: ParserExpr::Str("   ".into()),
-                span: Span::new(" ", 0, 1).unwrap(),
+                span: Span::new(" ", 0, 1),
             })),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(is_non_progressing(
@@ -1086,7 +1086,7 @@ mod tests {
     fn progressing_seqs() {
         let left_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("i'm make progress".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(!is_non_progressing(
@@ -1097,7 +1097,7 @@ mod tests {
 
         let left_non_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(is_non_progressing(
@@ -1108,7 +1108,7 @@ mod tests {
 
         let right_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Ident("DROP".into()),
-            span: Span::new("DROP", 0, 3).unwrap(),
+            span: Span::new("DROP", 0, 3),
         });
 
         assert!(!is_non_progressing(
@@ -1120,9 +1120,9 @@ mod tests {
         let right_non_progressing_node = Box::new(ParserNode {
             expr: ParserExpr::Opt(Box::new(ParserNode {
                 expr: ParserExpr::Str("   ".into()),
-                span: Span::new(" ", 0, 1).unwrap(),
+                span: Span::new(" ", 0, 1),
             })),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(is_non_progressing(
@@ -1214,7 +1214,7 @@ mod tests {
     fn non_failing_zero_length_repetitions() {
         let failing = Box::new(ParserNode {
             expr: ParserExpr::Range("A".into(), "B".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
         assert!(!is_non_failing(
             &failing.clone().expr,
@@ -1263,9 +1263,9 @@ mod tests {
         let non_failing = Box::new(ParserNode {
             expr: ParserExpr::Opt(Box::new(ParserNode {
                 expr: ParserExpr::Range("A".into(), "B".into()),
-                span: Span::new(" ", 0, 1).unwrap(),
+                span: Span::new(" ", 0, 1),
             })),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
         assert!(is_non_failing(
             &non_failing.clone().expr,
@@ -1301,11 +1301,11 @@ mod tests {
             expr: ParserExpr::NodeTag(
                 Box::new(ParserNode {
                     expr: ParserExpr::Range("A".into(), "B".into()),
-                    span: Span::new(" ", 0, 1).unwrap(),
+                    span: Span::new(" ", 0, 1),
                 }),
                 "Tag".into(),
             ),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
         assert!(!is_non_failing(
             &failing.clone().expr,
@@ -1338,7 +1338,7 @@ mod tests {
     fn failing_choice() {
         let left_failing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("i'm a failure".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
         assert!(!is_non_failing(
             &left_failing_node.clone().expr,
@@ -1348,7 +1348,7 @@ mod tests {
 
         let right_failing_node = Box::new(ParserNode {
             expr: ParserExpr::Ident("DROP".into()),
-            span: Span::new("DROP", 0, 3).unwrap(),
+            span: Span::new("DROP", 0, 3),
         });
 
         assert!(!is_non_failing(
@@ -1362,7 +1362,7 @@ mod tests {
     fn non_failing_choices() {
         let left_failing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("i'm a failure".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(!is_non_failing(
@@ -1373,7 +1373,7 @@ mod tests {
 
         let left_non_failing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(is_non_failing(
@@ -1384,7 +1384,7 @@ mod tests {
 
         let right_failing_node = Box::new(ParserNode {
             expr: ParserExpr::Ident("DROP".into()),
-            span: Span::new("DROP", 0, 3).unwrap(),
+            span: Span::new("DROP", 0, 3),
         });
 
         assert!(!is_non_failing(
@@ -1396,9 +1396,9 @@ mod tests {
         let right_non_failing_node = Box::new(ParserNode {
             expr: ParserExpr::Opt(Box::new(ParserNode {
                 expr: ParserExpr::Str("   ".into()),
-                span: Span::new(" ", 0, 1).unwrap(),
+                span: Span::new(" ", 0, 1),
             })),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(is_non_failing(
@@ -1428,15 +1428,15 @@ mod tests {
     fn non_failing_seq() {
         let left_non_failing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         let right_non_failing_node = Box::new(ParserNode {
             expr: ParserExpr::Opt(Box::new(ParserNode {
                 expr: ParserExpr::Str("   ".into()),
-                span: Span::new(" ", 0, 1).unwrap(),
+                span: Span::new(" ", 0, 1),
             })),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(is_non_failing(
@@ -1450,7 +1450,7 @@ mod tests {
     fn failing_seqs() {
         let left_failing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("i'm a failure".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(!is_non_failing(
@@ -1461,7 +1461,7 @@ mod tests {
 
         let left_non_failing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(is_non_failing(
@@ -1472,7 +1472,7 @@ mod tests {
 
         let right_failing_node = Box::new(ParserNode {
             expr: ParserExpr::Ident("DROP".into()),
-            span: Span::new("DROP", 0, 3).unwrap(),
+            span: Span::new("DROP", 0, 3),
         });
 
         assert!(!is_non_failing(
@@ -1484,9 +1484,9 @@ mod tests {
         let right_non_failing_node = Box::new(ParserNode {
             expr: ParserExpr::Opt(Box::new(ParserNode {
                 expr: ParserExpr::Str("   ".into()),
-                span: Span::new(" ", 0, 1).unwrap(),
+                span: Span::new(" ", 0, 1),
             })),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
 
         assert!(is_non_failing(
@@ -1529,7 +1529,7 @@ mod tests {
     fn _push_node_tag_pos_pred_forwarding_is_non_failing() {
         let failing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("i'm a failure".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
         assert!(!is_non_failing(
             &failing_node.clone().expr,
@@ -1538,7 +1538,7 @@ mod tests {
         ));
         let non_failing_node = Box::new(ParserNode {
             expr: ParserExpr::Str("".into()),
-            span: Span::new(" ", 0, 1).unwrap(),
+            span: Span::new(" ", 0, 1),
         });
         assert!(is_non_failing(
             &non_failing_node.clone().expr,