internal: Add Clone to parsers (#4642)

Author: max-sixty

prqlc/prqlc-parser/src/parser/common.rs

@@ -5,7 +5,7 @@ use crate::lexer::lr::TokenKind;
 use crate::parser::pr::{Annotation, Expr, ExprKind, Stmt, StmtKind, Ty, TyKind};
 use crate::span::Span;
 
-pub fn ident_part() -> impl Parser<TokenKind, String, Error = PError> {
+pub fn ident_part() -> impl Parser<TokenKind, String, Error = PError> + Clone {
     return select! {
         TokenKind::Ident(ident) => ident,
         TokenKind::Keyword(ident) if &ident == "module" => ident,

prqlc/prqlc-parser/src/parser/expr.rs

@@ -12,7 +12,7 @@ use crate::parser::pr::*;
 use crate::parser::types::type_expr;
 use crate::span::Span;
 
-pub fn expr_call() -> impl Parser<TokenKind, Expr, Error = PError> {
+pub fn expr_call() -> impl Parser<TokenKind, Expr, Error = PError> + Clone {
     let expr = expr();
 
     lambda_func(expr.clone()).or(func_call(expr))
@@ -231,9 +231,9 @@ pub fn expr() -> impl Parser<TokenKind, Expr, Error = PError> + Clone {
     })
 }
 
-pub fn pipeline<E>(expr: E) -> impl Parser<TokenKind, Expr, Error = PError>
+pub fn pipeline<E>(expr: E) -> impl Parser<TokenKind, Expr, Error = PError> + Clone
 where
-    E: Parser<TokenKind, Expr, Error = PError>,
+    E: Parser<TokenKind, Expr, Error = PError> + Clone,
 {
     // expr has to be a param, because it can be either a normal expr() or
     // a recursive expr called from within expr()
@@ -266,7 +266,7 @@ where
 pub fn binary_op_parser<'a, Term, Op>(
     term: Term,
     op: Op,
-) -> impl Parser<TokenKind, Expr, Error = PError> + 'a
+) -> impl Parser<TokenKind, Expr, Error = PError> + 'a + Clone
 where
     Term: Parser<TokenKind, Expr, Error = PError> + 'a,
     Op: Parser<TokenKind, BinOp, Error = PError> + 'a,
@@ -292,7 +292,7 @@ where
         .boxed()
 }
 
-fn func_call<E>(expr: E) -> impl Parser<TokenKind, Expr, Error = PError>
+fn func_call<E>(expr: E) -> impl Parser<TokenKind, Expr, Error = PError> + Clone
 where
     E: Parser<TokenKind, Expr, Error = PError> + Clone,
 {
@@ -344,7 +344,7 @@ where
         .labelled("function call")
 }
 
-fn lambda_func<E>(expr: E) -> impl Parser<TokenKind, Expr, Error = PError>
+fn lambda_func<E>(expr: E) -> impl Parser<TokenKind, Expr, Error = PError> + Clone
 where
     E: Parser<TokenKind, Expr, Error = PError> + Clone + 'static,
 {
@@ -404,7 +404,7 @@ where
     .labelled("function definition")
 }
 
-pub fn ident() -> impl Parser<TokenKind, Ident, Error = PError> {
+pub fn ident() -> impl Parser<TokenKind, Ident, Error = PError> + Clone {
     ident_part()
         .separated_by(ctrl('.'))
         .at_least(1)

prqlc/prqlc-parser/src/parser/stmt.rs

@@ -43,7 +43,7 @@ fn module_contents() -> impl Parser<TokenKind, Vec<Stmt>, Error = PError> {
     })
 }
 
-fn query_def() -> impl Parser<TokenKind, Stmt, Error = PError> {
+fn query_def() -> impl Parser<TokenKind, Stmt, Error = PError> + Clone {
     new_line()
         .repeated()
         .ignore_then(keyword("prql"))
@@ -112,7 +112,7 @@ fn query_def() -> impl Parser<TokenKind, Stmt, Error = PError> {
         .labelled("query header")
 }
 
-fn var_def() -> impl Parser<TokenKind, StmtKind, Error = PError> {
+fn var_def() -> impl Parser<TokenKind, StmtKind, Error = PError> + Clone {
     let let_ = keyword("let")
         .ignore_then(ident_part())
         .then(type_expr().delimited_by(ctrl('<'), ctrl('>')).or_not())
@@ -150,15 +150,15 @@ fn var_def() -> impl Parser<TokenKind, StmtKind, Error = PError> {
     let_.or(main_or_into)
 }
 
-fn type_def() -> impl Parser<TokenKind, StmtKind, Error = PError> {
+fn type_def() -> impl Parser<TokenKind, StmtKind, Error = PError> + Clone {
     keyword("type")
         .ignore_then(ident_part())
         .then(ctrl('=').ignore_then(type_expr()).or_not())
         .map(|(name, value)| StmtKind::TypeDef(TypeDef { name, value }))
         .labelled("type definition")
 }
 
-fn import_def() -> impl Parser<TokenKind, StmtKind, Error = PError> {
+fn import_def() -> impl Parser<TokenKind, StmtKind, Error = PError> + Clone {
     keyword("import")
         .ignore_then(ident_part().then_ignore(ctrl('=')).or_not())
         .then(ident())

prqlc/prqlc-parser/src/parser/types.rs

@@ -6,7 +6,7 @@ use crate::lexer::lr::TokenKind;
 use crate::parser::expr::ident;
 use crate::parser::pr::*;
 
-pub fn type_expr() -> impl Parser<TokenKind, Ty, Error = PError> {
+pub fn type_expr() -> impl Parser<TokenKind, Ty, Error = PError> + Clone {
     recursive(|nested_type_expr| {
         let basic = select! {
             TokenKind::Literal(lit) => TyKind::Singleton(lit),