refactor(common): Deleted CaseInsensitiveStr for simplicity

Author: ngeor

rusty_basic/src/interpreter/context.rs

@@ -1,7 +1,6 @@
-use std::borrow::Borrow;
 use std::collections::HashMap;
 
-use rusty_common::*;
+use rusty_common::CaseInsensitiveString;
 use rusty_linter::{QBNumberCast, SubprogramName};
 use rusty_parser::{BareName, BuiltInFunction, TypeQualifier};
 use rusty_variant::{UserDefinedTypeValue, VArray, Variant, bytes_to_i32, i32_to_bytes};
@@ -253,7 +252,7 @@ impl Context {
                 match self.find_value_in_caller_context(parent_path)? {
                     Variant::VUserDefined(v_u) => Ok(address_offset_of_property(
                         v_u.as_ref(),
-                        property_name.borrow(),
+                        property_name,
                     ) + parent_var_ptr),
                     _ => panic!("Expected user defined type"),
                 }
@@ -502,7 +501,7 @@ fn address_offset_of_element(v: &VArray, indices: &[i32]) -> Result<usize, Runti
         .map_err(RuntimeError::from)
 }
 
-fn address_offset_of_property(v: &UserDefinedTypeValue, name: &CaseInsensitiveStr) -> usize {
+fn address_offset_of_property(v: &UserDefinedTypeValue, name: &CaseInsensitiveString) -> usize {
     v.names()
         .take_while(|p| *p != name)
         .flat_map(|p| v.get(p))

rusty_common/src/case_insensitive_str.rs

@@ -1,10 +1,8 @@
-use std::borrow::Borrow;
 use std::cmp::Ordering;
 use std::fmt::Formatter;
 use std::hash::{Hash, Hasher};
 use std::ops::{Deref, DerefMut};
 
-use crate::CaseInsensitiveStr;
 use crate::case_insensitive_utils::{cmp_str, hash_str};
 
 /// A string that is case insensitive when comparing or checking for equality.
@@ -42,17 +40,16 @@ impl CaseInsensitiveString {
     /// # Examples
     ///
     /// ```
-    /// use rusty_common::CaseInsensitiveStr;
     /// use rusty_common::CaseInsensitiveString;
-    /// assert_eq!(CaseInsensitiveString::from("a.b").prefix('.'), Some(CaseInsensitiveStr::new("a")));
+    /// assert_eq!(CaseInsensitiveString::from("a.b").prefix('.'), Some(CaseInsensitiveString::from("a")));
     /// assert_eq!(CaseInsensitiveString::from("ab").prefix('.'), None);
     /// ```
-    pub fn prefix(&self, delimiter: char) -> Option<&CaseInsensitiveStr> {
+    pub fn prefix(&self, delimiter: char) -> Option<CaseInsensitiveString> {
         if self.contains(delimiter) {
             let parts: Vec<&str> = self.0.split('.').collect();
             debug_assert!(!parts.is_empty());
             let first = parts[0];
-            Some(CaseInsensitiveStr::new(first))
+            Some(CaseInsensitiveString::from(first))
         } else {
             None
         }
@@ -93,12 +90,6 @@ impl PartialEq for CaseInsensitiveString {
 
 impl Eq for CaseInsensitiveString {}
 
-impl Borrow<CaseInsensitiveStr> for CaseInsensitiveString {
-    fn borrow(&self) -> &CaseInsensitiveStr {
-        CaseInsensitiveStr::new(&self.0)
-    }
-}
-
 impl From<String> for CaseInsensitiveString {
     fn from(x: String) -> Self {
         Self::new(x)

rusty_common/src/case_insensitive_string.rs

@@ -1,12 +1,14 @@
 use std::cmp::Ordering;
 use std::hash::{Hash, Hasher};
 
+/// Creates a hash for a [str] ignoring case.
 pub fn hash_str<H: Hasher>(s: &str, state: &mut H) {
     for byte in s.as_bytes() {
         byte.to_ascii_uppercase().hash(state);
     }
 }
 
+/// Compares two [str] ignoring case.
 pub fn cmp_str(left: &str, right: &str) -> Ordering {
     cmp_bytes(left.as_bytes(), right.as_bytes())
 }

rusty_common/src/case_insensitive_utils.rs

@@ -1,11 +1,9 @@
 //! The `common` module contains shared functionality (not specific to `rusty-basic`).
-mod case_insensitive_str;
 mod case_insensitive_string;
 mod case_insensitive_utils;
 mod position;
 mod positioned;
 
-pub use self::case_insensitive_str::*;
 pub use self::case_insensitive_string::*;
 pub use self::case_insensitive_utils::*;
 pub use self::position::*;

rusty_common/src/lib.rs

@@ -86,7 +86,7 @@ impl NoDotNamesCheck<BareName, LintError> for DotsLinter {
     fn ensure_no_dots(&self, x: &BareName) -> Result<(), LintError> {
         match x.prefix('.') {
             Some(part_before_dot) => {
-                if self.user_defined_names.contains(part_before_dot) {
+                if self.user_defined_names.contains(&part_before_dot) {
                     Err(LintError::DotClash)
                 } else {
                     Ok(())

rusty_linter/src/post_linter/dots_linter.rs

@@ -2,7 +2,7 @@ use std::borrow::Borrow;
 use std::collections::HashMap;
 use std::hash::Hash;
 
-use rusty_common::{CaseInsensitiveStr, CaseInsensitiveString};
+use rusty_common::CaseInsensitiveString;
 
 use crate::Variant;
 
@@ -43,8 +43,8 @@ impl UserDefinedTypeValue {
         self.name_to_value.get_mut(name)
     }
 
-    pub fn names(&self) -> impl Iterator<Item = &CaseInsensitiveStr> + '_ {
-        self.ordered_property_names.iter().map(|s| s.borrow())
+    pub fn names(&self) -> impl Iterator<Item = &CaseInsensitiveString> {
+        self.ordered_property_names.iter()
     }
 
     pub fn values(&self) -> impl Iterator<Item = &Variant> + '_ {
@@ -56,13 +56,6 @@ impl UserDefinedTypeValue {
 mod tests {
     use super::*;
 
-    #[test]
-    fn test_get_by_case_insensitive_str() {
-        let name = CaseInsensitiveStr::new("Card");
-        let u = UserDefinedTypeValue::new(vec![(name.to_owned(), Variant::VInteger(42))]);
-        assert_eq!(u.get(name), Some(&Variant::VInteger(42)));
-    }
-
     #[test]
     fn test_get_by_case_insensitive_string() {
         let name = CaseInsensitiveString::from("Card");
@@ -72,13 +65,13 @@ mod tests {
 
     #[test]
     fn test_get_mut() {
-        let name = CaseInsensitiveStr::new("Address");
+        let name = CaseInsensitiveString::from("Address");
         let mut u =
             UserDefinedTypeValue::new(vec![(name.to_owned(), Variant::VString("home".to_owned()))]);
-        if let Some(v) = u.get_mut(name) {
+        if let Some(v) = u.get_mut(&name) {
             *v = Variant::VString("work".to_owned());
         }
-        assert_eq!(u.get(name), Some(&Variant::VString("work".to_owned())));
+        assert_eq!(u.get(&name), Some(&Variant::VString("work".to_owned())));
     }
 
     #[test]
@@ -87,12 +80,12 @@ mod tests {
             (CaseInsensitiveString::from("Row"), Variant::VInteger(1)),
             (CaseInsensitiveString::from("Col"), Variant::VInteger(2)),
         ]);
-        let names: Vec<&CaseInsensitiveStr> = u.names().collect();
+        let names: Vec<&CaseInsensitiveString> = u.names().collect();
         assert_eq!(
             names,
             vec![
-                CaseInsensitiveStr::new("Row"),
-                CaseInsensitiveStr::new("Col")
+                &CaseInsensitiveString::from("Row"),
+                &CaseInsensitiveString::from("Col")
             ]
         );
     }