Only pass parser settings when checking function parameters.

Passing the whole parser allows to access too many things, like the
scheme and potentially other things we might add in the future.
It also makes writing unit tests more cumbersome since we now have
to build a scheme first just to get a dummy parser.

engine/src/ast/field_expr.rs

@@ -645,8 +645,10 @@ impl<'s> Expr<'s> for ComparisonExpr<'s> {
 mod tests {
     use super::*;
     use crate::{
-        ast::function_expr::{FunctionCallArgExpr, FunctionCallExpr},
-        ast::logical_expr::LogicalExpr,
+        ast::{
+            function_expr::{FunctionCallArgExpr, FunctionCallExpr},
+            logical_expr::LogicalExpr,
+        },
         execution_context::ExecutionContext,
         functions::{
             FunctionArgKind, FunctionArgs, FunctionDefinition, FunctionDefinitionContext,
@@ -658,7 +660,7 @@ mod tests {
         rhs_types::{IpRange, RegexFormat},
         scheme::{FieldIndex, IndexAccessError, Scheme},
         types::ExpectedType,
-        BytesFormat,
+        BytesFormat, ParserSettings,
     };
     use cidr::IpCidr;
     use std::sync::LazyLock;
@@ -715,7 +717,7 @@ mod tests {
     impl FunctionDefinition for FilterFunction {
         fn check_param(
             &self,
-            _: &FilterParser<'_>,
+            _: &ParserSettings,
             params: &mut dyn ExactSizeIterator<Item = FunctionParam<'_>>,
             next_param: &FunctionParam<'_>,
             _: Option<&mut FunctionDefinitionContext>,

engine/src/ast/function_expr.rs

@@ -418,7 +418,7 @@ impl<'s> FunctionCallExpr<'s> {
 
             definition
                 .check_param(
-                    parser,
+                    parser.settings(),
                     &mut args.iter().map(|arg| arg.into()),
                     &next_param,
                     ctx.as_mut(),

engine/src/ast/parse.rs

@@ -96,29 +96,56 @@ impl Display for ParseError<'_> {
     }
 }
 
+/// Parser settings.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ParserSettings {
+    /// Approximate size of the cache used by the DFA of a regex.
+    /// Default: 10MB
+    pub regex_dfa_size_limit: usize,
+    /// Approximate size limit of the compiled regular expression.
+    /// Default: 2MB
+    pub regex_compiled_size_limit: usize,
+    /// Maximum number of star metacharacters allowed in a wildcard.
+    /// Default: unlimited
+    pub wildcard_star_limit: usize,
+}
+
+impl Default for ParserSettings {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            // Default value extracted from the regex crate.
+            regex_compiled_size_limit: 10 * (1 << 20),
+            // Default value extracted from the regex crate.
+            regex_dfa_size_limit: 2 * (1 << 20),
+            wildcard_star_limit: usize::MAX,
+        }
+    }
+}
+
 /// A structure used to drive parsing of an expression into a [`FilterAst`].
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct FilterParser<'s> {
     pub(crate) scheme: &'s Scheme,
-    pub(crate) regex_dfa_size_limit: usize,
-    pub(crate) regex_compiled_size_limit: usize,
-    pub(crate) wildcard_star_limit: usize,
+    pub(crate) settings: ParserSettings,
 }
 
 impl<'s> FilterParser<'s> {
-    /// Creates a new parser with default configuration.
+    /// Creates a new parser with default settings.
     #[inline]
     pub fn new(scheme: &'s Scheme) -> Self {
         Self {
             scheme,
-            // Default value extracted from the regex crate.
-            regex_compiled_size_limit: 10 * (1 << 20),
-            // Default value extracted from the regex crate.
-            regex_dfa_size_limit: 2 * (1 << 20),
-            wildcard_star_limit: usize::MAX,
+            settings: ParserSettings::default(),
         }
     }
 
+    /// Creates a new parser with the specified settings.
+    #[inline]
+    pub fn with_settings(scheme: &'s Scheme, settings: ParserSettings) -> Self {
+        Self { scheme, settings }
+    }
+
     /// Returns the [`Scheme`](struct@Scheme) for which this parser has been constructor for.
     #[inline]
     pub fn scheme(&self) -> &'s Scheme {
@@ -143,39 +170,45 @@ impl<'s> FilterParser<'s> {
         complete(self.lex_as(input.trim())).map_err(|err| ParseError::new(input, err))
     }
 
+    /// Retrieve parser settings.
+    #[inline]
+    pub fn settings(&self) -> &ParserSettings {
+        &self.settings
+    }
+
     /// Set the approximate size limit of the compiled regular expression.
     #[inline]
     pub fn regex_set_compiled_size_limit(&mut self, regex_compiled_size_limit: usize) {
-        self.regex_compiled_size_limit = regex_compiled_size_limit;
+        self.settings.regex_compiled_size_limit = regex_compiled_size_limit;
     }
 
     /// Get the approximate size limit of the compiled regular expression.
     #[inline]
     pub fn regex_get_compiled_size_limit(&self) -> usize {
-        self.regex_compiled_size_limit
+        self.settings.regex_compiled_size_limit
     }
 
     /// Set the approximate size of the cache used by the DFA of a regex.
     #[inline]
     pub fn regex_set_dfa_size_limit(&mut self, regex_dfa_size_limit: usize) {
-        self.regex_dfa_size_limit = regex_dfa_size_limit;
+        self.settings.regex_dfa_size_limit = regex_dfa_size_limit;
     }
 
     /// Get the approximate size of the cache used by the DFA of a regex.
     #[inline]
     pub fn regex_get_dfa_size_limit(&self) -> usize {
-        self.regex_dfa_size_limit
+        self.settings.regex_dfa_size_limit
     }
 
     /// Set the maximum number of star metacharacters allowed in a wildcard.
     #[inline]
     pub fn wildcard_set_star_limit(&mut self, wildcard_star_limit: usize) {
-        self.wildcard_star_limit = wildcard_star_limit;
+        self.settings.wildcard_star_limit = wildcard_star_limit;
     }
 
     /// Get the maximum number of star metacharacters allowed in a wildcard.
     #[inline]
     pub fn wildcard_get_star_limit(&self) -> usize {
-        self.wildcard_star_limit
+        self.settings.wildcard_star_limit
     }
 }

engine/src/functions.rs

@@ -1,7 +1,7 @@
 use crate::{
     filter::CompiledValueResult,
     types::{ExpectedType, ExpectedTypeList, GetType, LhsValue, RhsValue, Type, TypeMismatchError},
-    FilterParser,
+    ParserSettings,
 };
 use std::any::Any;
 use std::convert::TryFrom;
@@ -371,7 +371,7 @@ pub trait FunctionDefinition: Debug + Send + Sync {
     /// correct. Return the expected the parameter definition.
     fn check_param(
         &self,
-        parser: &FilterParser<'_>,
+        settings: &ParserSettings,
         params: &mut dyn ExactSizeIterator<Item = FunctionParam<'_>>,
         next_param: &FunctionParam<'_>,
         ctx: Option<&mut FunctionDefinitionContext>,
@@ -460,7 +460,7 @@ pub struct SimpleFunctionDefinition {
 impl FunctionDefinition for SimpleFunctionDefinition {
     fn check_param(
         &self,
-        _parser: &FilterParser<'_>,
+        _settings: &ParserSettings,
         params: &mut dyn ExactSizeIterator<Item = FunctionParam<'_>>,
         next_param: &FunctionParam<'_>,
         _: Option<&mut FunctionDefinitionContext>,

engine/src/lib.rs

@@ -84,7 +84,7 @@ pub use self::{
         function_expr::{FunctionCallArgExpr, FunctionCallExpr},
         index_expr::IndexExpr,
         logical_expr::{LogicalExpr, LogicalOp, ParenthesizedExpr, UnaryOp},
-        parse::{FilterParser, ParseError},
+        parse::{FilterParser, ParseError, ParserSettings},
         visitor::{Visitor, VisitorMut},
         Expr, FilterAst, FilterValueAst, ValueExpr,
     },

engine/src/rhs_types/regex/imp_real.rs

@@ -18,8 +18,8 @@ impl Regex {
     ) -> Result<Self, Error> {
         ::regex::bytes::RegexBuilder::new(pattern)
             .unicode(false)
-            .size_limit(parser.regex_compiled_size_limit)
-            .dfa_size_limit(parser.regex_dfa_size_limit)
+            .size_limit(parser.settings.regex_compiled_size_limit)
+            .dfa_size_limit(parser.settings.regex_dfa_size_limit)
             .build()
             .map(|r| Regex {
                 compiled_regex: r,

engine/src/rhs_types/wildcard.rs

@@ -126,7 +126,7 @@ impl<const STRICT: bool> Serialize for Wildcard<STRICT> {
 impl<'i, 's, const STRICT: bool> LexWith<'i, &FilterParser<'s>> for Wildcard<STRICT> {
     fn lex_with(input: &'i str, parser: &FilterParser<'s>) -> LexResult<'i, Wildcard<STRICT>> {
         lex_quoted_or_raw_string(input).and_then(|(pattern, rest)| {
-            match Wildcard::new(pattern, parser.wildcard_star_limit) {
+            match Wildcard::new(pattern, parser.settings.wildcard_star_limit) {
                 Ok(wildcard) => Ok((wildcard, rest)),
                 Err(err) => Err((LexErrorKind::ParseWildcard(err), input)),
             }

engine/src/scheme.rs

@@ -1,6 +1,8 @@
 use crate::{
-    ast::parse::{FilterParser, ParseError},
-    ast::{FilterAst, FilterValueAst},
+    ast::{
+        parse::{FilterParser, ParseError, ParserSettings},
+        FilterAst, FilterValueAst,
+    },
     functions::FunctionDefinition,
     lex::{expect, span, take_while, Lex, LexErrorKind, LexResult, LexWith},
     list_matcher::ListDefinition,
@@ -536,6 +538,16 @@ impl<'s> Scheme {
         })
     }
 
+    /// Creates a new parser with default settings.
+    pub fn parser(&self) -> FilterParser<'_> {
+        FilterParser::new(self)
+    }
+
+    /// Creates a new parser with the specified settings.
+    pub fn parser_with_settings(&self, settings: ParserSettings) -> FilterParser<'_> {
+        FilterParser::with_settings(self, settings)
+    }
+
     /// Parses a filter expression into an AST form.
     pub fn parse<'i>(&'s self, input: &'i str) -> Result<FilterAst<'s>, ParseError<'i>> {
         FilterParser::new(self).parse(input)