adding error messages

Author: robertbastian

provider/core/src/resource.rs

@@ -36,16 +36,16 @@ impl ResourceKeyHash {
 ///
 /// ```
 /// # use icu_provider::prelude::ResourceKey;
-/// const key: ResourceKey = icu_provider::resource_key!("foo/bar@1");
+/// const K: ResourceKey = icu_provider::resource_key!("foo/bar@1");
 /// ```
 ///
 /// The path string has to contain at least one `/`, and end with `@` followed by one or more ASCII
 /// digits. Paths do not contain characters other than ASCII letters and digits, `_`, `/`, `=`, and
-/// `@`. Invalid paths are compile-time errors (as [`resource_key!`] is `const`).
+/// `@`. Invalid paths are compile-time errors (as [`resource_key!`] uses `const`).
 ///
-/// ```compile_fail
+/// ```compile_fail,E0080
 /// # use icu_provider::prelude::ResourceKey;
-/// const key: ResourceKey = icu_provider::resource_key!("foobar@1");
+/// const K: ResourceKey = icu_provider::resource_key!("foobar@1");
 /// ```
 #[derive(PartialEq, Eq, Copy, Clone)]
 pub struct ResourceKey {
@@ -114,9 +114,10 @@ impl ResourceKey {
     }
 
     #[doc(hidden)]
-    pub const fn try_new(path: &'static str) -> Option<Self> {
+    // Error is a str of the expected character class and the index where it wasn't encountered
+    pub const fn construct_internal(path: &'static str) -> Result<Self, (&'static str, usize)> {
         if path.len() < leading_tag!().len() + trailing_tag!().len() {
-            return None;
+            return Err(("tag", 0));
         }
         // Start and end of the untagged part
         let start = leading_tag!().len();
@@ -126,46 +127,75 @@ impl ResourceKey {
         let mut i = 0;
         while i < leading_tag!().len() {
             if path.as_bytes()[i] != leading_tag!().as_bytes()[i] {
-                return None;
+                return Err(("tag", 0));
             }
             i += 1;
         }
         i = 0;
         while i < trailing_tag!().len() {
             if path.as_bytes()[end + i] != trailing_tag!().as_bytes()[i] {
-                return None;
+                return Err(("tag", end + 1));
             }
             i += 1;
         }
 
-        // Approximate regex: \w+(/\w+)*@\d+
-        // State 0 = start of string
-        // State 1 = after first character
-        // State 2 = after a slash
-        // State 3 = after a character after a slash
-        // State 4 = after @
-        // State 5 = after a digit after @
+        // Regex: [a-zA-Z0-9=_]+(/[a-zA-Z0-9=_]+)*@[0-9]+
+        enum State {
+            Start,
+            AfterChar,
+            AfterSlash,
+            AfterCharAfterSlash,
+            AfterAt,
+            AfterDigit,
+        }
+        use State::*;
         i = start;
-        let mut state = 0;
-        while i < end {
-            state = match (state, path.as_bytes()[i]) {
-                (0 | 1, b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | b'=') => 1,
-                (1, b'/') => 2,
-                (2 | 3, b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | b'=') => 3,
-                (3, b'/') => 2,
-                (3, b'@') => 4,
-                (4 | 5, b'0'..=b'9') => 5,
-                _ => return None,
+        let mut state = Start;
+        loop {
+            state = match (
+                state,
+                if i < end {
+                    Some(path.as_bytes()[i])
+                } else {
+                    None
+                },
+            ) {
+                (Start, Some(b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | b'=')) => AfterChar,
+                (Start, _) => return Err(("[a-zA-Z0-9=_]", i)),
+
+                (AfterChar, Some(b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | b'=')) => {
+                    AfterChar
+                }
+                (AfterChar, Some(b'/')) => AfterSlash,
+                (AfterChar, _) => return Err(("[a-zA-z0-9=_/]", i)),
+
+                (AfterSlash, Some(b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | b'=')) => {
+                    AfterCharAfterSlash
+                }
+                (AfterSlash, _) => return Err(("[a-zA-Z0-9=_]", i)),
+
+                (
+                    AfterCharAfterSlash,
+                    Some(b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | b'='),
+                ) => AfterCharAfterSlash,
+                (AfterCharAfterSlash, Some(b'/')) => AfterSlash,
+                (AfterCharAfterSlash, Some(b'@')) => AfterAt,
+                (AfterCharAfterSlash, _) => return Err(("[a-zA-z0-9=_/@]", i)),
+
+                (AfterAt, Some(b'0'..=b'9')) => AfterDigit,
+                (AfterAt, _) => return Err(("[0-9]", i)),
+
+                (AfterDigit, Some(b'0'..=b'9')) => AfterDigit,
+                (AfterDigit, Some(_)) => return Err(("[0-9]", i)),
+                (AfterDigit, None) => {
+                    return Ok(Self {
+                        path,
+                        hash: ResourceKeyHash::compute_from_str(path),
+                    })
+                }
             };
             i += 1;
         }
-        if state != 5 {
-            return None;
-        }
-        Some(Self {
-            path,
-            hash: ResourceKeyHash::compute_from_str(path),
-        })
     }
 
     /// Gets the last path component of a [`ResourceKey`] without the version suffix.
@@ -234,27 +264,56 @@ impl ResourceKey {
 #[test]
 fn test_path_syntax() {
     // Valid keys:
-    assert!(ResourceKey::try_new(tagged!("hello/world@1")).is_some());
-    assert!(ResourceKey::try_new(tagged!("hello/world/foo@1")).is_some());
-    assert!(ResourceKey::try_new(tagged!("hello/world@999")).is_some());
-    assert!(ResourceKey::try_new(tagged!("hello_world/foo@1")).is_some());
-    assert!(ResourceKey::try_new(tagged!("hello_458/world@1")).is_some());
+    assert!(ResourceKey::construct_internal(tagged!("hello/world@1")).is_ok());
+    assert!(ResourceKey::construct_internal(tagged!("hello/world/foo@1")).is_ok());
+    assert!(ResourceKey::construct_internal(tagged!("hello/world@999")).is_ok());
+    assert!(ResourceKey::construct_internal(tagged!("hello_world/foo@1")).is_ok());
+    assert!(ResourceKey::construct_internal(tagged!("hello_458/world@1")).is_ok());
 
     // No slash:
-    assert!(ResourceKey::try_new(tagged!("hello_world@1")).is_none());
+    assert_eq!(
+        ResourceKey::construct_internal(tagged!("hello_world@1")),
+        Err(("[a-zA-z0-9=_/]", 25))
+    );
 
     // No version:
-    assert!(ResourceKey::try_new(tagged!("hello/world")).is_none());
-    assert!(ResourceKey::try_new(tagged!("hello/world@")).is_none());
-    assert!(ResourceKey::try_new(tagged!("hello/world@foo")).is_none());
+    assert_eq!(
+        ResourceKey::construct_internal(tagged!("hello/world")),
+        Err(("[a-zA-z0-9=_/@]", 25))
+    );
+
+    assert_eq!(
+        ResourceKey::construct_internal(tagged!("hello/world@")),
+        Err(("[0-9]", 26))
+    );
+    assert_eq!(
+        ResourceKey::construct_internal(tagged!("hello/world@foo")),
+        Err(("[0-9]", 26))
+    );
+    assert_eq!(
+        ResourceKey::construct_internal(tagged!("hello/world@1foo")),
+        Err(("[0-9]", 27))
+    );
 
     // Invalid characters:
-    assert!(ResourceKey::try_new(tagged!("你好/世界@1")).is_none());
+    assert_eq!(
+        ResourceKey::construct_internal(tagged!("你好/世界@1")),
+        Err(("[a-zA-Z0-9=_]", 14))
+    );
 
     // Invalid tag:
-    assert!(ResourceKey::try_new(concat!("hello/world@1", trailing_tag!())).is_none());
-    assert!(ResourceKey::try_new(concat!(leading_tag!(), "hello/world@1")).is_none());
-    assert!(ResourceKey::try_new("hello/world@1").is_none());
+    assert_eq!(
+        ResourceKey::construct_internal(concat!("hello/world@1", trailing_tag!())),
+        Err(("tag", 0))
+    );
+    assert_eq!(
+        ResourceKey::construct_internal(concat!(leading_tag!(), "hello/world@1")),
+        Err(("tag", 27))
+    );
+    assert_eq!(
+        ResourceKey::construct_internal("hello/world@1"),
+        Err(("tag", 0))
+    );
 }
 
 /// See [`ResourceKey`].
@@ -263,9 +322,16 @@ macro_rules! resource_key {
     ($path:expr) => {{
         // Force the ResourceKey into a const context
         const RESOURCE_KEY_MACRO_CONST: $crate::ResourceKey = {
-            match $crate::ResourceKey::try_new($crate::tagged!($path)) {
-                Some(v) => v,
-                None => panic!(concat!("Invalid resource key: ", $path)),
+            match $crate::ResourceKey::construct_internal($crate::tagged!($path)) {
+                Ok(v) => v,
+                Err(_) => panic!(concat!("Invalid resource key: ", $path)),
+                // TODO Once formatting is const:
+                // Err((expected, index)) => panic!(
+                //     "Invalid resource key {:?}: expected {:?}, found {:?} ",
+                //     $path,
+                //     expected,
+                //     $crate::tagged!($path).get(index..))
+                // );
             }
         };
         RESOURCE_KEY_MACRO_CONST