chore: Improve keyword_enum macro

No need to use a separate slice for storing `CaseInsensitiveStr`
members. Implemented binary search with custom case insensitive
comparator using `binary_search_by`.

Removed the dependency of the `keyword_enum` to `CaseInsensitiveStr`
altogether.

Author: ngeor

rusty_common/src/lib.rs

@@ -7,5 +7,6 @@ mod positioned;
 
 pub use self::case_insensitive_str::*;
 pub use self::case_insensitive_string::*;
+pub use self::case_insensitive_utils::*;
 pub use self::position::*;
 pub use self::positioned::*;

rusty_parser/src/specific/built_ins/built_in_function.rs

@@ -1,11 +1,10 @@
-use crate::keyword_enum;
 use crate::specific::{QualifiedName, TypeQualifier};
+use crate::{keyword_enum, BareName};
 use rusty_common::*;
-use std::borrow::Borrow;
 use std::convert::TryFrom;
 
 keyword_enum!(
-pub enum BuiltInFunction SORTED_BUILT_IN_FUNCTIONS SORTED_BUILT_IN_FUNCTION_NAMES SORTED_BUILT_IN_FUNCTIONS_CI_STR {
+pub enum BuiltInFunction SORTED_BUILT_IN_FUNCTIONS SORTED_BUILT_IN_FUNCTION_NAMES {
     /// `CHR$(ascii-code%)` returns the text representation of the given ascii code
     Chr,
 
@@ -163,10 +162,7 @@ impl From<BuiltInFunction> for QualifiedName {
 // CaseInsensitiveString -> BuiltInFunction
 
 impl BuiltInFunction {
-    pub fn try_parse<S>(s: &S) -> Option<Self>
-    where
-        S: Borrow<CaseInsensitiveStr>,
-    {
-        Self::try_from(s.borrow()).ok()
+    pub fn try_parse(s: &BareName) -> Option<Self> {
+        Self::try_from(s.as_str()).ok()
     }
 }

rusty_parser/src/specific/core/keyword.rs

@@ -1,6 +1,7 @@
 use crate::pc::Token;
 use crate::specific::pc_specific::TokenType;
-use rusty_common::CaseInsensitiveStr;
+
+use rusty_common::cmp_str;
 
 // From the internets:
 // Doc comments are secretly just attributes,
@@ -13,7 +14,7 @@ use rusty_common::CaseInsensitiveStr;
 
 #[macro_export]
 macro_rules! keyword_enum {
-    ($vis:vis enum $name:ident $all_names:ident $all_names_as_str:ident $all_names_as_case_insensitive_str:ident {
+    ($vis:vis enum $name:ident $all_names:ident $all_names_as_str:ident {
         $($(#[$($attrss:tt)*])*$member:ident),+$(,)?
     }) => {
         #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
@@ -25,14 +26,10 @@ macro_rules! keyword_enum {
             $($name::$member),+
         ];
 
-        pub const $all_names_as_str : &[&str] = &[
+        const $all_names_as_str : &[&str] = &[
             $(stringify!($member)),+
         ];
 
-        const $all_names_as_case_insensitive_str : &[&CaseInsensitiveStr] = &[
-            $( CaseInsensitiveStr::new( stringify!($member) ) ),+
-        ];
-
         impl std::fmt::Display for $name {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 self.as_ref().to_uppercase().fmt(f)
@@ -48,19 +45,19 @@ macro_rules! keyword_enum {
             }
         }
 
-        impl TryFrom<&CaseInsensitiveStr> for $name {
+        impl TryFrom<&str> for $name {
             type Error = usize;
 
-            fn try_from(s: &CaseInsensitiveStr) -> Result<$name, usize> {
-                $all_names_as_case_insensitive_str.binary_search(&s)
+            fn try_from(s: &str) -> Result<$name, usize> {
+                $all_names_as_str.binary_search_by(|probe| cmp_str(probe, s))
                     .map(|index| $all_names[index])
             }
         }
 
     };
 }
 
-keyword_enum!(pub enum Keyword SORTED_KEYWORDS SORTED_KEYWORDS_STR SORTED_KEYWORDS_CI_STR {
+keyword_enum!(pub enum Keyword SORTED_KEYWORDS SORTED_KEYWORDS_STR {
     /// ACCESS
     Access,
     /// AND
@@ -220,8 +217,7 @@ impl PartialEq<Token> for Keyword {
 impl From<&Token> for Keyword {
     fn from(token: &Token) -> Self {
         debug_assert_eq!(token.kind, TokenType::Keyword.into());
-        let temp = CaseInsensitiveStr::new(&token.text);
-        Self::try_from(temp).expect("Token keyword not found in keywords!")
+        Self::try_from(token.text.as_str()).expect("Token keyword not found in keywords!")
     }
 }
 

rusty_parser/src/specific/core/mod.rs

@@ -59,7 +59,7 @@ pub use self::global_statement::{
     program_parser_p, FunctionDeclaration, FunctionImplementation, GlobalStatement,
     GlobalStatementPos, Program, SubDeclaration, SubImplementation, SubprogramImplementation,
 };
-pub use self::keyword::{Keyword, SORTED_KEYWORDS_STR};
+pub use self::keyword::Keyword;
 pub use self::letter_range::LetterRange;
 pub use self::name::{Name, NameAsTokens, NamePos};
 pub use self::operator::Operator;

rusty_parser/src/specific/pc_specific/recognizers_impl.rs

@@ -5,7 +5,7 @@ use crate::pc::*;
 use crate::specific::pc_specific::recognizers_impl::string_parsers::CharToStringParser;
 use crate::specific::pc_specific::recognizers_impl::token_parsers::StringToTokenParser;
 use crate::specific::pc_specific::TokenType;
-use crate::specific::SORTED_KEYWORDS_STR;
+use crate::Keyword;
 use std::fs::File;
 
 // TODO keyword --> ensure not followed by dollar sign
@@ -137,15 +137,8 @@ fn digits() -> impl Parser<RcStringView, Output = Token> {
 fn keyword() -> impl Parser<RcStringView, Output = Token> {
     // using is_ascii_alphanumeric to read e.g. Sub1 and determine it is not a keyword
     // TODO can be done in a different way e.g. read alphabetic and then ensure it's followed by something other than alphanumeric
-    many(TokenType::Keyword, char::is_ascii_alphanumeric).filter(|token| {
-        let text = &token.text;
-        for keyword in SORTED_KEYWORDS_STR {
-            if keyword.eq_ignore_ascii_case(text) {
-                return true;
-            }
-        }
-        false
-    })
+    many(TokenType::Keyword, char::is_ascii_alphanumeric)
+        .filter(|token| Keyword::try_from(token.text.as_str()).is_ok())
 }
 
 fn identifier() -> impl Parser<RcStringView, Output = Token> {