Add arguments check errors

The `ArgumentBounds` trait was redefined
only because `usize` does not implement the `RangeBounds<usize>` trait.

Author: B-head

gdnative-core/src/export/method.rs

@@ -3,6 +3,7 @@
 use std::borrow::Cow;
 use std::fmt;
 use std::marker::PhantomData;
+use std::ops::Bound;
 
 use crate::core_types::{FromVariant, FromVariantError, Variant};
 use crate::export::class::NativeClass;
@@ -298,6 +299,285 @@ impl<'a> Iterator for Varargs<'a> {
     }
 }
 
+/// All possible error types for convert from Varargs.
+#[derive(Debug)]
+pub enum VarargsError {
+    ArgumentTypeError(ArgumentTypeError),
+    ArgumentLengthError(ArgumentLengthError),
+}
+
+impl std::error::Error for VarargsError {}
+impl std::fmt::Display for VarargsError {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self {
+            VarargsError::ArgumentTypeError(e) => e.fmt(f),
+            VarargsError::ArgumentLengthError(e) => e.fmt(f),
+        }
+    }
+}
+
+impl From<ArgumentTypeError> for VarargsError {
+    #[inline]
+    fn from(value: ArgumentTypeError) -> Self {
+        Self::ArgumentTypeError(value)
+    }
+}
+
+impl From<ArgumentLengthError> for VarargsError {
+    #[inline]
+    fn from(value: ArgumentLengthError) -> Self {
+        Self::ArgumentLengthError(value)
+    }
+}
+
+/// Error to argument type do not match.
+#[derive(Debug)]
+pub struct ArgumentTypeError {
+    index: usize,
+    nested_error: FromVariantError,
+}
+
+impl ArgumentTypeError {
+    /// Create a new error with the argument position and `FromVariantError`.
+    #[inline]
+    #[must_use]
+    pub fn new(index: usize, nested_error: FromVariantError) -> Self {
+        Self {
+            index,
+            nested_error,
+        }
+    }
+
+    /// Returns an ordinal number representation.
+    #[inline]
+    #[must_use]
+    fn ordinal(&self) -> String {
+        match self.index + 1 {
+            1 => "1st".to_owned(),
+            2 => "2nd".to_owned(),
+            3 => "3rd".to_owned(),
+            i @ 4.. => format!("{i}th"),
+            _ => "unknown".to_owned(),
+        }
+    }
+
+    /// Get the argument type error's index.
+    #[inline]
+    #[must_use]
+    pub fn index(&self) -> usize {
+        self.index
+    }
+
+    /// Get a reference to the argument type error's nested error.
+    #[inline]
+    #[must_use]
+    pub fn nested_error(&self) -> &FromVariantError {
+        &self.nested_error
+    }
+}
+
+impl std::error::Error for ArgumentTypeError {}
+impl std::fmt::Display for ArgumentTypeError {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "Incorrect type of {} argument, Cause: {}",
+            self.ordinal(),
+            self.nested_error,
+        )
+    }
+}
+
+/// Error to argument lengths do not match.
+#[derive(Debug)]
+pub struct ArgumentLengthError {
+    passed: usize,
+    expected_min: usize,
+    expected_max: usize,
+}
+
+impl ArgumentLengthError {
+    /// Creates a new error with the length of the arguments passed and the expected arguments range.
+    #[inline]
+    #[must_use]
+    pub fn new(passed: usize, expected: impl ArgumentBounds) -> Self {
+        Self {
+            passed,
+            expected_min: expected.start_bound(),
+            expected_max: expected.end_bound(),
+        }
+    }
+
+    /// Get the argument length error's passed.
+    #[inline]
+    #[must_use]
+    pub fn passed(&self) -> usize {
+        self.passed
+    }
+
+    /// Get the argument length error's expected min.
+    #[inline]
+    #[must_use]
+    pub fn expected_min(&self) -> usize {
+        self.expected_min
+    }
+
+    /// Get the argument length error's expected max.
+    #[inline]
+    #[must_use]
+    pub fn expected_max(&self) -> usize {
+        self.expected_max
+    }
+}
+
+impl std::error::Error for ArgumentLengthError {}
+impl std::fmt::Display for ArgumentLengthError {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let expected_msg = match (self.expected_min, self.expected_max) {
+            (usize::MIN, usize::MAX) => "any".to_owned(),
+            (usize::MIN, e) => format!("max {e}"),
+            (s, usize::MAX) => format!("min {s}"),
+            (s, e) => {
+                if s == e {
+                    s.to_string()
+                } else {
+                    format!("min {s} and max {e}")
+                }
+            }
+        };
+        write!(
+            f,
+            "Argument lengths do not match, passed {}, expected {}",
+            self.passed, expected_msg
+        )
+    }
+}
+
+/// Produced by range syntax like `a`, `(a, b)`, ..`, `a..`, `..b`, `..=c`, `d..e`, or `f..=g`.
+pub trait ArgumentBounds {
+    /// Start index bound.
+    fn start_bound(&self) -> usize;
+    /// End index bound.
+    fn end_bound(&self) -> usize;
+
+    /// Returns true if item is contained in the range.
+    #[inline]
+    fn contains<U>(&self, item: &U) -> bool
+    where
+        usize: PartialOrd<U>,
+        U: ?Sized + PartialOrd<usize>,
+    {
+        (self.start_bound() <= *item) && (*item <= self.end_bound())
+    }
+}
+
+impl ArgumentBounds for usize {
+    #[inline]
+    fn start_bound(&self) -> usize {
+        *self
+    }
+
+    #[inline]
+    fn end_bound(&self) -> usize {
+        *self
+    }
+}
+
+impl ArgumentBounds for (Bound<usize>, Bound<usize>) {
+    #[inline]
+    fn start_bound(&self) -> usize {
+        match self.0 {
+            Bound::Included(s) => s,
+            Bound::Excluded(s) => s + 1,
+            Bound::Unbounded => usize::MIN,
+        }
+    }
+
+    #[inline]
+    fn end_bound(&self) -> usize {
+        match self.1 {
+            Bound::Included(e) => e,
+            Bound::Excluded(e) => e - 1,
+            Bound::Unbounded => usize::MAX,
+        }
+    }
+}
+
+impl ArgumentBounds for std::ops::Range<usize> {
+    #[inline]
+    fn start_bound(&self) -> usize {
+        self.start
+    }
+
+    #[inline]
+    fn end_bound(&self) -> usize {
+        self.end - 1
+    }
+}
+
+impl ArgumentBounds for std::ops::RangeFrom<usize> {
+    #[inline]
+    fn start_bound(&self) -> usize {
+        self.start
+    }
+
+    #[inline]
+    fn end_bound(&self) -> usize {
+        usize::MAX
+    }
+}
+
+impl ArgumentBounds for std::ops::RangeInclusive<usize> {
+    #[inline]
+    fn start_bound(&self) -> usize {
+        *self.start()
+    }
+
+    #[inline]
+    fn end_bound(&self) -> usize {
+        *self.end()
+    }
+}
+
+impl ArgumentBounds for std::ops::RangeTo<usize> {
+    #[inline]
+    fn start_bound(&self) -> usize {
+        usize::MIN
+    }
+
+    #[inline]
+    fn end_bound(&self) -> usize {
+        self.end - 1
+    }
+}
+
+impl ArgumentBounds for std::ops::RangeToInclusive<usize> {
+    #[inline]
+    fn start_bound(&self) -> usize {
+        usize::MIN
+    }
+
+    #[inline]
+    fn end_bound(&self) -> usize {
+        self.end
+    }
+}
+
+impl ArgumentBounds for std::ops::RangeFull {
+    #[inline]
+    fn start_bound(&self) -> usize {
+        usize::MIN
+    }
+
+    #[inline]
+    fn end_bound(&self) -> usize {
+        usize::MAX
+    }
+}
+
 /// Trait for structures that can be parsed from `Varargs`.
 ///
 /// This trait can be derived for structure types where each type implements `FromVariant`.