feat!(stdlib): add return_kind and return_rules to Function (#1628)

* Automatically add return_kind and return_rules to all stdlib functions

* Add return_kind to undocumented functions

* format

Author: thomasqueirozb

src/compiler/expression/function_call.rs

@@ -1276,6 +1276,10 @@ mod tests {
             "Test function"
         }
 
+        fn return_kind(&self) -> u16 {
+            kind::NULL
+        }
+
         fn examples(&self) -> &'static [crate::compiler::function::Example] {
             &[]
         }

src/compiler/function.rs

@@ -40,6 +40,18 @@ pub trait Function: Send + Sync + fmt::Debug {
     fn internal_failure_reasons(&self) -> &'static [&'static str] {
         &[]
     }
+
+    /// The return type kind(s) this function can return.
+    fn return_kind(&self) -> u16;
+
+    /// Human-readable rules describing the return value of the function.
+    ///
+    /// This returns an empty slice by default, indicating no return rules
+    /// are documented for this function.
+    fn return_rules(&self) -> &'static [&'static str] {
+        &[]
+    }
+
     /// One or more examples demonstrating usage of the function in VRL source
     /// code.
     fn examples(&self) -> &'static [Example];

src/stdlib/abs.rs

@@ -24,6 +24,14 @@ impl Function for Abs {
         "Computes the absolute value of `value`."
     }
 
+    fn return_kind(&self) -> u16 {
+        kind::INTEGER | kind::FLOAT
+    }
+
+    fn return_rules(&self) -> &'static [&'static str] {
+        &["Returns the absolute value."]
+    }
+
     fn parameters(&self) -> &'static [Parameter] {
         &[Parameter {
             keyword: "value",

src/stdlib/append.rs

@@ -19,6 +19,10 @@ impl Function for Append {
         "Appends each item in the `items` array to the end of the `value` array."
     }
 
+    fn return_kind(&self) -> u16 {
+        kind::ARRAY
+    }
+
     fn parameters(&self) -> &'static [Parameter] {
         &[
             Parameter {

src/stdlib/array.rs

@@ -23,6 +23,17 @@ impl Function for Array {
         &["`value` is not an array."]
     }
 
+    fn return_kind(&self) -> u16 {
+        kind::ARRAY
+    }
+
+    fn return_rules(&self) -> &'static [&'static str] {
+        &[
+            "Returns the `value` if it's an array.",
+            "Raises an error if not an array.",
+        ]
+    }
+
     fn parameters(&self) -> &'static [Parameter] {
         &[Parameter {
             keyword: "value",

src/stdlib/assert.rs

@@ -35,6 +35,10 @@ impl Function for Assert {
         &["`condition` evaluates to `false`."]
     }
 
+    fn return_kind(&self) -> u16 {
+        kind::BOOLEAN
+    }
+
     fn parameters(&self) -> &'static [Parameter] {
         &[
             Parameter {

src/stdlib/assert_eq.rs

@@ -29,6 +29,10 @@ impl Function for AssertEq {
         "Asserts that two expressions, `left` and `right`, have the same value. The program is aborted with `message` if they do not have the same value."
     }
 
+    fn return_kind(&self) -> u16 {
+        kind::BOOLEAN
+    }
+
     fn parameters(&self) -> &'static [Parameter] {
         &[
             Parameter {

src/stdlib/basename.rs

@@ -26,6 +26,10 @@ impl Function for BaseName {
         &["`value` is not a valid string."]
     }
 
+    fn return_kind(&self) -> u16 {
+        kind::BYTES | kind::NULL
+    }
+
     fn parameters(&self) -> &'static [Parameter] {
         &[Parameter {
             keyword: "value",

src/stdlib/boolean.rs

@@ -23,6 +23,17 @@ impl Function for Boolean {
         &["`value` is not a Boolean."]
     }
 
+    fn return_kind(&self) -> u16 {
+        kind::BOOLEAN
+    }
+
+    fn return_rules(&self) -> &'static [&'static str] {
+        &[
+            "Returns `value` if it's a Boolean.",
+            "Raises an error if not a Boolean.",
+        ]
+    }
+
     fn parameters(&self) -> &'static [Parameter] {
         &[Parameter {
             keyword: "value",

src/stdlib/casing/camelcase.rs

@@ -15,6 +15,10 @@ impl Function for Camelcase {
         "Takes the `value` string, and turns it into camelCase. Optionally, you can pass in the existing case of the function, or else an attempt is made to determine the case automatically."
     }
 
+    fn return_kind(&self) -> u16 {
+        kind::BYTES
+    }
+
     fn parameters(&self) -> &'static [Parameter] {
         &[
             Parameter {