Add feature gate to allow trailing args.

Author: Tehforsch

rust/nasl-builtin-std/src/array.rs

@@ -27,7 +27,7 @@ fn make_array(positionals: CheckedPositionals<NaslValue>) -> HashMap<String, Nas
             values.insert(positionals[idx - 1].to_string(), val.clone());
         }
     }
-    values.into()
+    values
 }
 
 fn create_list(positionals: CheckedPositionals<NaslValue>) -> Vec<NaslValue> {

rust/nasl-builtin-string/src/lib.rs

@@ -127,7 +127,7 @@ fn write_nasl_string(s: &mut String, value: &NaslValue) -> Result<(), FunctionEr
 fn string(positional: CheckedPositionals<&NaslValue>) -> Result<NaslValue, FunctionErrorKind> {
     let mut s = String::with_capacity(2 * positional.len());
     for p in positional {
-        write_nasl_string_value(&mut s, &p)?;
+        write_nasl_string_value(&mut s, p)?;
     }
     Ok(s.into())
 }

rust/nasl-builtin-utils/Cargo.toml

@@ -10,3 +10,7 @@ nasl-syntax = { path = "../nasl-syntax" }
 storage = { path = "../storage" }
 thiserror = "1.0.62"
 tracing = "0.1"
+
+[features]
+default = ["enforce-no-trailing-arguments"]
+enforce-no-trailing-arguments = []

rust/nasl-builtin-utils/src/context.rs

@@ -183,7 +183,7 @@ impl Register {
     }
 
     /// Return an iterator over the names of the named arguments.
-    pub fn iter_named_args<'a>(&'a self) -> Option<impl Iterator<Item = &str>> {
+    pub fn iter_named_args(&self) -> Option<impl Iterator<Item = &str>> {
         self.blocks
             .last()
             .map(|x| x.defined.keys().map(|x| x.as_str()))

rust/nasl-builtin-utils/src/function/utils.rs

@@ -112,21 +112,23 @@ pub fn get_maybe_named_arg<'a, T: FromNaslValue<'a>>(
 /// as a named argument.
 fn check_named_args(
     register: &Register,
+    _nasl_fn_name: &str,
     named: &[&str],
     maybe_named: &[&str],
 ) -> Result<usize, FunctionErrorKind> {
     let mut num_maybe_named = 0;
     for arg_name in register.iter_named_args().unwrap() {
-        if arg_name == FC_ANON_ARGS {
+        if arg_name == FC_ANON_ARGS || named.contains(&arg_name) {
             continue;
+        } else if maybe_named.contains(&arg_name) {
+            num_maybe_named += 1;
         } else {
-            if named.contains(&arg_name) {
-                continue;
-            } else if maybe_named.contains(&arg_name) {
-                num_maybe_named += 1;
-            } else {
-                return Err(FunctionErrorKind::UnexpectedArgument(arg_name.into()));
-            }
+            #[cfg(feature = "enforce-no-trailing-arguments")]
+            return Err(FunctionErrorKind::UnexpectedArgument(arg_name.into()));
+            #[cfg(not(feature = "enforce-no-trailing-arguments"))]
+            tracing::debug!(
+                "Unexpected named argument '{arg_name}' in NASL function {_nasl_fn_name}."
+            );
         }
     }
     Ok(num_maybe_named)
@@ -137,19 +139,25 @@ fn check_named_args(
 /// named arguments exist.
 pub fn check_args(
     register: &Register,
+    _nasl_fn_name: &str,
     named: &[&str],
     maybe_named: &[&str],
     max_num_expected_positional: Option<usize>,
 ) -> Result<(), FunctionErrorKind> {
-    let num_maybe_named_given = check_named_args(register, named, maybe_named)?;
+    let num_maybe_named_given = check_named_args(register, _nasl_fn_name, named, maybe_named)?;
     let num_positional_given = register.positional().len();
     if let Some(max_num_expected_positional) = max_num_expected_positional {
         let num_positional_expected = max_num_expected_positional - num_maybe_named_given;
         if num_positional_given > num_positional_expected {
+            #[cfg(feature = "enforce-no-trailing-arguments")]
             return Err(FunctionErrorKind::TrailingPositionalArguments {
                 expected: num_positional_expected,
                 got: num_positional_given,
             });
+            #[cfg(not(feature = "enforce-no-trailing-arguments"))]
+            tracing::debug!(
+                "Trailing positional arguments in NASL function {_nasl_fn_name}. Expected {num_positional_expected}, found {num_positional_given}"
+            );
         }
     }
     Ok(())

rust/nasl-function-proc-macro/src/codegen.rs

@@ -121,8 +121,9 @@ impl<'a> ArgsStruct<'a> {
             let num = self.max_num_allowed_positional();
             quote! { Some(#num) }
         };
+        let fn_name = self.function.sig.ident.to_string();
         quote! {
-            ::nasl_builtin_utils::function::utils::check_args(_register, #named_array, #maybe_named_array, #num_allowed_positional_args)?;
+            ::nasl_builtin_utils::function::utils::check_args(_register, #fn_name, #named_array, #maybe_named_array, #num_allowed_positional_args)?;
         }
     }