[change] TokenSet が持つメソッドの命名を Syntax に合わせた

Author: Yuta1004

crates/algorithm_lr1/src/builder.rs

@@ -72,7 +72,7 @@ where
         let mut goto_table: Vec<Vec<usize>> = Vec::with_capacity(dfa.0.len());
         for _ in 0..dfa.0.len() {
             action_table.push(HashMap::from_iter(
-                T::enum_iter()
+                T::into_iter()
                     .map(|token| (token, LRAction::None))
                     .collect::<Vec<(T, LRAction<S>)>>(),
             ));

crates/core/src/cfg/syntax.rs

@@ -244,7 +244,7 @@ mod test {
     }
 
     impl TokenSet<'_> for TestToken {
-        fn enum_iter() -> impl Iterator<Item = Self> {
+        fn into_iter() -> impl Iterator<Item = Self> {
             Box::new(
                 vec![
                     TestToken::Num,
@@ -259,7 +259,7 @@ mod test {
             )
         }
 
-        fn to_regex(&self) -> &'static str {
+        fn into_regex_str(&self) -> &'static str {
             match self {
                 TestToken::Num => r"^[1-9][0-9]*",
                 TestToken::Plus => r"^\+",

crates/core/src/cfg/token.rs

@@ -1,19 +1,25 @@
 use std::fmt::Debug;
 use std::hash::Hash;
 
-use regex::Regex;
+use regex::{Regex, RegexSet};
 
 pub trait TokenSet<'a>
 where
     Self: Debug + Copy + Clone + Hash + Eq,
 {
     fn ignore_str() -> &'a str;
-    fn enum_iter() -> impl Iterator<Item = Self>;
-    fn to_regex(&self) -> &'a str;
+    fn into_iter() -> impl Iterator<Item = Self>;
+    fn into_regex_str(&self) -> &'a str;
 
-    fn try_into() -> anyhow::Result<Vec<(Regex, Self)>> {
-        Self::enum_iter()
-            .map(|token| Ok((Regex::new(Self::to_regex(&token))?, token)))
-            .collect::<anyhow::Result<Vec<_>>>()
+    fn into_regex(&self) -> anyhow::Result<Regex> {
+        Ok(Regex::new(self.into_regex_str())?)
+    }
+
+    fn try_into_regexset() -> anyhow::Result<RegexSet> {
+        let regex_set = Self::into_iter()
+            .map(|token| Self::into_regex_str(&token))
+            .collect::<Vec<_>>();
+
+        Ok(RegexSet::new(regex_set)?)
     }
 }

crates/core/src/lex.rs

@@ -41,9 +41,9 @@ impl Lexer {
 
 struct LexDriver<'a, 'b, T: TokenSet<'a>> {
     // Regex
+    regex_istr: Regex,
     regex_set: RegexSet,
     regex_map: Vec<(Regex, T)>,
-    regex_istr: Regex,
 
     // State
     input: &'b str,
@@ -57,18 +57,16 @@ impl<'a, 'b, T: TokenSet<'a>> TryFrom<&'b str> for LexDriver<'a, 'b, T> {
     type Error = anyhow::Error;
 
     fn try_from(input: &'b str) -> anyhow::Result<Self> {
-        let regex_map = T::try_into()?;
-        let regex_set = regex_map
-            .iter()
-            .map(|(_, token)| T::to_regex(&token))
-            .collect::<Vec<_>>();
-        let regex_set = RegexSet::new(regex_set)?;
         let regex_istr = Regex::new(T::ignore_str())?;
+        let regex_set = T::try_into_regexset()?;
+        let regex_map = T::into_iter()
+            .map(|token| Ok((token.into_regex()?, token)))
+            .collect::<anyhow::Result<Vec<_>>>()?;
 
         Ok(LexDriver {
+            regex_istr,
             regex_set,
             regex_map,
-            regex_istr,
             input,
             pos: 0,
             tokenset: PhantomData,
@@ -126,11 +124,11 @@ mod test {
             r"^[ \t\n]+"
         }
 
-        fn enum_iter() -> Box<dyn Iterator<Item = Self>> {
-            Box::new(vec![TestToken::Num, TestToken::Plus].into_iter())
+        fn into_iter() -> impl Iterator<Item = Self> {
+            vec![TestToken::Num, TestToken::Plus].into_iter()
         }
 
-        fn to_regex(&self) -> &'static str {
+        fn into_regex_str(&self) -> &'static str {
             match self {
                 TestToken::Num => r"^[1-9][0-9]*",
                 TestToken::Plus => r"^\+",

crates/core_derive/src/impl/tokenset.rs

@@ -36,13 +36,13 @@ pub fn proc_macro_impl(ast: DeriveInput) -> TokenStream {
                 #enum_ignored
             }
 
-            fn enum_iter() -> impl Iterator<Item = Self> {
+            fn into_iter() -> impl Iterator<Item = Self> {
                 vec![
                     #( #enum_variants, )*
                 ].into_iter()
             }
 
-            fn to_regex(&self) -> &'static str {
+            fn into_regex_str(&self) -> &'static str {
                 match self {
                     #( #enum_regex_table, )*
                     _ => unimplemented!(),

tests/derive.rs

@@ -42,6 +42,6 @@ enum TestSyntax {
 
 #[test]
 fn check_compile() {
-    let _ = TestTokenSet::to_regex(&self::TestTokenSet::Plus);
+    let _ = TestTokenSet::into_regex(&self::TestTokenSet::Plus);
     let _ = TestSyntax::into_rule(&self::TestSyntax::ExprPlus);
 }