Upgrade to nom 6, fix errors

Author: gzsombor

Cargo.toml

@@ -14,7 +14,7 @@ license = "MIT"
 [dependencies]
 serde = "1.0"
 serde_derive = "1.0"
-nom = "5.0.1"
+nom = "6"
 
 [dev-dependencies]
 pretty_assertions = "0.5.1"

src/arithmetic.rs

@@ -185,7 +185,7 @@ fn arithmetic(i: &[u8]) -> IResult<&[u8], Arithmetic> {
     match res.1 {
         ArithmeticItem::Base(ArithmeticBase::Column(_))
         | ArithmeticItem::Base(ArithmeticBase::Scalar(_)) => {
-            Err(Error((i, nom::error::ErrorKind::Tag)))
+            Err(Error(nom::error::Error::new(i, nom::error::ErrorKind::Tag)))
         } // no operator
         ArithmeticItem::Base(ArithmeticBase::Bracketed(expr)) => Ok((res.0, *expr)),
         ArithmeticItem::Expr(expr) => Ok((res.0, *expr)),
@@ -463,6 +463,6 @@ mod tests {
         let qs = "56";
         let res = arithmetic(qs.as_bytes());
         assert!(res.is_err());
-        assert_eq!(nom::Err::Error((qs.as_bytes(), ErrorKind::Tag)), res.err().unwrap());
+        assert_eq!(nom::Err::Error(nom::error::Error::new(qs.as_bytes(), ErrorKind::Tag)), res.err().unwrap());
     }
 }

src/common.rs

@@ -2,7 +2,7 @@ use nom::branch::alt;
 use nom::character::complete::{alphanumeric1, digit1, line_ending, multispace0, multispace1};
 use nom::character::is_alphanumeric;
 use nom::combinator::{map, not, peek};
-use nom::{IResult, InputLength};
+use nom::{IResult, InputLength, Parser};
 use std::fmt::{self, Display};
 use std::str;
 use std::str::FromStr;
@@ -14,7 +14,7 @@ use keywords::{escape_if_keyword, sql_keyword};
 use nom::bytes::complete::{is_not, tag, tag_no_case, take, take_until, take_while1};
 use nom::combinator::opt;
 use nom::error::{ErrorKind, ParseError};
-use nom::multi::{fold_many0, many0, many1, separated_list};
+use nom::multi::{fold_many0, many0, many1, separated_list0};
 use nom::sequence::{delimited, pair, preceded, separated_pair, terminated, tuple};
 use table::Table;
 
@@ -371,24 +371,24 @@ fn len_as_u16(len: &[u8]) -> u16 {
 }
 
 pub(crate) fn opt_delimited<I: Clone, O1, O2, O3, E: ParseError<I>, F, G, H>(
-    first: F,
-    second: G,
-    third: H,
-) -> impl Fn(I) -> IResult<I, O2, E>
+    mut first: F,
+    mut second: G,
+    mut third: H,
+) -> impl FnMut(I) -> IResult<I, O2, E>
 where
-    F: Fn(I) -> IResult<I, O1, E>,
-    G: Fn(I) -> IResult<I, O2, E>,
-    H: Fn(I) -> IResult<I, O3, E>,
+    F: Parser<I, O1, E>,
+    G: Parser<I, O2, E>,
+    H: Parser<I, O3, E>,
 {
     move |input: I| {
-        let first_ = &first;
-        let second_ = &second;
-        let third_ = &third;
-
         let inp = input.clone();
-        match second(input) {
+        match second.parse(input) {
             Ok((i, o)) => Ok((i, o)),
-            _ => delimited(first_, second_, third_)(inp),
+            _ => {
+                let (inp, _) = first.parse(inp)?;
+                let (inp, o2) = second.parse(inp)?;
+                third.parse(inp).map(|(i, _)| (i, o2))
+            },
         }
     }
 }
@@ -695,7 +695,7 @@ pub fn column_function(i: &[u8]) -> IResult<&[u8], FunctionExpression> {
                 FunctionExpression::GroupConcat(FunctionArgument::Column(col.clone()), sep)
             },
         ),
-        map(tuple((sql_identifier, multispace0, tag("("), separated_list(tag(","), delimited(multispace0, function_argument_parser, multispace0)), tag(")"))), |tuple| {
+        map(tuple((sql_identifier, multispace0, tag("("), separated_list0(tag(","), delimited(multispace0, function_argument_parser, multispace0)), tag(")"))), |tuple| {
             let (name, _, _, arguments, _) = tuple;
             FunctionExpression::Generic(
                 str::from_utf8(name).unwrap().to_string(), 

src/compound_select.rs

@@ -185,17 +185,17 @@ mod tests {
         assert!(&res.is_err());
         assert_eq!(
             res.unwrap_err(),
-            nom::Err::Error((");".as_bytes(), nom::error::ErrorKind::Tag))
+            nom::Err::Error(nom::error::Error::new(");".as_bytes(), nom::error::ErrorKind::Tag))
         );
         assert!(&res2.is_err());
         assert_eq!(
             res2.unwrap_err(),
-            nom::Err::Error((";".as_bytes(), nom::error::ErrorKind::Tag))
+            nom::Err::Error(nom::error::Error::new(";".as_bytes(), nom::error::ErrorKind::Tag))
         );
         assert!(&res3.is_err());
         assert_eq!(
             res3.unwrap_err(),
-            nom::Err::Error((
+            nom::Err::Error(nom::error::Error::new(
                 ") UNION (SELECT id, stars from Rating;".as_bytes(),
                 nom::error::ErrorKind::Tag
             ))

src/create_table_options.rs

@@ -4,14 +4,14 @@ use common::{integer_literal, sql_identifier, string_literal, ws_sep_comma, ws_s
 use nom::branch::alt;
 use nom::bytes::complete::{tag, tag_no_case};
 use nom::combinator::{map, opt};
-use nom::multi::separated_list;
+use nom::multi::separated_list0;
 use nom::sequence::tuple;
 use nom::IResult;
 
 pub fn table_options(i: &[u8]) -> IResult<&[u8], ()> {
     // TODO: make the create options accessible
     map(
-        separated_list(table_options_separator, create_option),
+        separated_list0(table_options_separator, create_option),
         |_| (),
     )(i)
 }
@@ -39,12 +39,12 @@ fn create_option(i: &[u8]) -> IResult<&[u8], ()> {
 /// Helper to parse equals-separated create option pairs.
 /// Throws away the create option and value
 pub fn create_option_equals_pair<'a, I, O1, O2, F, G>(
-    first: F,
-    second: G,
-) -> impl Fn(I) -> IResult<I, ()>
+    mut first: F,
+    mut second: G,
+) -> impl FnMut(I) -> IResult<I, ()>
 where
-    F: Fn(I) -> IResult<I, O1>,
-    G: Fn(I) -> IResult<I, O2>,
+    F: FnMut(I) -> IResult<I, O1>,
+    G: FnMut(I) -> IResult<I, O2>,
     I: nom::InputTakeAtPosition + nom::InputTake + nom::Compare<&'a str>,
     <I as nom::InputTakeAtPosition>::Item: nom::AsChar + Clone,
 {

src/select.rs

@@ -528,7 +528,7 @@ mod tests {
 
         let res1 = selection(qstring1.as_bytes());
         assert_eq!(
-            res1.clone().unwrap().1,
+            res1.unwrap().1,
             SelectStatement {
                 tables: vec![Table {
                     name: String::from("PaperTag"),
@@ -549,7 +549,7 @@ mod tests {
 
         let res1 = selection(qstring1.as_bytes());
         assert_eq!(
-            res1.clone().unwrap().1,
+            res1.unwrap().1,
             SelectStatement {
                 tables: vec![Table {
                     name: String::from("PaperTag"),
@@ -571,7 +571,7 @@ mod tests {
 
         let res1 = selection(qstring1.as_bytes());
         assert_eq!(
-            res1.clone().unwrap().1,
+            res1.unwrap().1,
             SelectStatement {
                 tables: vec![Table::from("PaperTag")],
                 fields: vec![FieldDefinitionExpression::Col(Column {
@@ -585,7 +585,7 @@ mod tests {
         );
         let res2 = selection(qstring2.as_bytes());
         assert_eq!(
-            res2.clone().unwrap().1,
+            res2.unwrap().1,
             SelectStatement {
                 tables: vec![Table::from("PaperTag")],
                 fields: vec![FieldDefinitionExpression::Col(Column {
@@ -606,7 +606,7 @@ mod tests {
 
         let res1 = selection(qstring1.as_bytes());
         assert_eq!(
-            res1.clone().unwrap().1,
+            res1.unwrap().1,
             SelectStatement {
                 tables: vec![Table::from("PaperTag")],
                 fields: vec![FieldDefinitionExpression::Col(Column {
@@ -620,7 +620,7 @@ mod tests {
         );
         let res2 = selection(qstring2.as_bytes());
         assert_eq!(
-            res2.clone().unwrap().1,
+            res2.unwrap().1,
             SelectStatement {
                 tables: vec![Table::from("PaperTag")],
                 fields: vec![FieldDefinitionExpression::Col(Column {