Optimize performance

Author: zbraniecki

src/negotiate/likely_subtags.rs

@@ -1,7 +1,25 @@
-use icu_locid::LanguageIdentifier;
+use icu_locid::{
+    langid,
+    subtags::{language, region, Language, Region},
+    LanguageIdentifier,
+};
 
-static REGION_MATCHING_KEYS: &[&str] = &[
-    "az", "bg", "cs", "de", "es", "fi", "fr", "hu", "it", "lt", "lv", "nl", "pl", "ro", "ru",
+static REGION_MATCHING_KEYS: &[(Language, Region)] = &[
+    (language!("az"), region!("AZ")),
+    (language!("bg"), region!("BG")),
+    (language!("cs"), region!("CS")),
+    (language!("de"), region!("DE")),
+    (language!("es"), region!("ES")),
+    (language!("fi"), region!("FI")),
+    (language!("fr"), region!("FR")),
+    (language!("nu"), region!("NU")),
+    (language!("it"), region!("IT")),
+    (language!("lt"), region!("LT")),
+    (language!("lv"), region!("LV")),
+    (language!("nl"), region!("NL")),
+    (language!("pl"), region!("PL")),
+    (language!("ro"), region!("RO")),
+    (language!("ru"), region!("RU")),
 ];
 
 pub trait MockLikelySubtags {
@@ -10,30 +28,29 @@ pub trait MockLikelySubtags {
 
 impl MockLikelySubtags for LanguageIdentifier {
     fn maximize(&mut self) -> bool {
-        let extended = match self.to_string().as_str() {
-            "en" => "en-Latn-US",
-            "fr" => "fr-Latn-FR",
-            "sr" => "sr-Cyrl-SR",
-            "sr-RU" => "sr-Latn-SR",
-            "az-IR" => "az-Arab-IR",
-            "zh-GB" => "zh-Hant-GB",
-            "zh-US" => "zh-Hant-US",
+        let extended = match &self {
+            b if *b == &langid!("en") => langid!("en-Latn-US"),
+            b if *b == &langid!("fr") => langid!("fr-Latn-FR"),
+            b if *b == &langid!("sr") => langid!("sr-Cyrl-SR"),
+            b if *b == &langid!("sr-RU") => langid!("sr-Latn-SR"),
+            b if *b == &langid!("az-IR") => langid!("az-Arab-IR"),
+            b if *b == &langid!("zh-GB") => langid!("zh-Hant-GB"),
+            b if *b == &langid!("zh-US") => langid!("zh-Hant-US"),
             _ => {
-                let lang = self.language;
+                let lang = &self.language;
 
-                for subtag in REGION_MATCHING_KEYS {
-                    if lang.strict_cmp(subtag.as_bytes()).is_eq() {
-                        self.region = Some(subtag.parse().unwrap());
-                        return true;
-                    }
+                if let Ok(idx) = REGION_MATCHING_KEYS.binary_search_by(|(l, _)| l.cmp(lang)) {
+                    let subtag = REGION_MATCHING_KEYS[idx].1;
+                    self.region = Some(subtag);
+                    return true;
                 }
                 return false;
             }
         };
-        let langid: LanguageIdentifier = extended.parse().expect("Failed to parse langid.");
-        self.language = langid.language;
-        self.script = langid.script;
-        self.region = langid.region;
+        let (language, script, region) = (extended.language, extended.script, extended.region);
+        self.language = language;
+        self.script = script;
+        self.region = region;
         true
     }
 }

src/negotiate/mod.rs

@@ -148,23 +148,14 @@ fn matches(
     range1: bool,
     range2: bool,
 ) -> bool {
-    let language = (range1 && lid1.language.is_empty())
+    ((range1 && lid1.language.is_empty())
         || (range2 && lid2.language.is_empty())
-        || lid1.language == lid2.language;
-    if !language {
-        return false;
-    }
-    let script = subtag_matches(&lid1.script, &lid2.script, range1, range2);
-    if !script {
-        return false;
-    }
-    let region = subtag_matches(&lid1.region, &lid2.region, range1, range2);
-    if !region {
-        return false;
-    }
-    (range1 && lid1.variants.is_empty())
-        || (range2 && lid2.variants.is_empty())
-        || lid1.variants == lid2.variants
+        || lid1.language == lid2.language)
+        && subtag_matches(&lid1.script, &lid2.script, range1, range2)
+        && subtag_matches(&lid1.region, &lid2.region, range1, range2)
+        && ((range1 && lid1.variants.is_empty())
+            || (range2 && lid2.variants.is_empty())
+            || lid1.variants == lid2.variants)
 }
 
 pub fn filter_matches<'a, R: 'a + AsRef<LanguageIdentifier>, A: 'a + AsRef<LanguageIdentifier>>(
@@ -177,7 +168,7 @@ pub fn filter_matches<'a, R: 'a + AsRef<LanguageIdentifier>, A: 'a + AsRef<Langu
     let mut available_locales: Vec<&A> = available.iter().collect();
 
     for req in requested {
-        let mut req = req.as_ref().to_owned();
+        let req = req.as_ref();
         macro_rules! test_strategy {
             ($self_as_range:expr, $other_as_range:expr) => {{
                 let mut match_found = false;
@@ -216,6 +207,7 @@ pub fn filter_matches<'a, R: 'a + AsRef<LanguageIdentifier>, A: 'a + AsRef<Langu
             continue;
         }
 
+        let mut req = req.to_owned();
         // 3) Try to match against a maximized version of the requested locale
         if req.maximize() {
             test_strategy!(true, false);