[update] 1つの列挙子に対して複数の #rule を指定できるようにした

Yuta1004 · Yuta1004 · commit d6b34e8ae827 · 2024-05-20T23:09:37.000+09:00
diff --git a/crates/algorithm_lr1/src/builder.rs b/crates/algorithm_lr1/src/builder.rs
@@ -37,6 +37,7 @@ where
 {
     pub fn setup() -> anyhow::Result<Self> {
         // 1. Pre-process
+        let rules = S::into_iter().collect::<Vec<_>>();
         let ruleset = S::into_ruleset();
         let first_set = ruleset.first_set();
 
@@ -81,7 +82,6 @@ where
         }
 
         // 5. Setup tables
-        let rule_table: Vec<S> = S::into_iter().collect();
         for lritem_set in &dfa.0 {
             for (token, next) in &lritem_set.next {
                 match &token {
@@ -109,7 +109,7 @@ where
                             let id = lritem_set.id as usize;
                             let label = action_table[id].get_mut(&t.0).unwrap();
                             *label = LRAction::Reduce(
-                                rule_table[item.rule.id as usize],
+                                rules[item.rule.id as usize],
                                 *nonterm_table.get(lhs).unwrap(),
                                 item.rule.rhs.len(),
                             );
@@ -120,7 +120,7 @@ where
                                 LRAction::Accept
                             } else {
                                 LRAction::Reduce(
-                                    rule_table[item.rule.id as usize],
+                                    rules[item.rule.id as usize],
                                     *nonterm_table.get(lhs).unwrap(),
                                     item.rule.rhs.len(),
                                 )
diff --git a/crates/algorithm_lr1/src/lib.rs b/crates/algorithm_lr1/src/lib.rs
@@ -68,19 +68,14 @@ mod test {
     #[derive(Debug, Clone, Copy, Syntax)]
     enum TestSyntax {
         #[rule("<expr> ::= <expr> Plus <term>")]
-        ExprPlus,
         #[rule("<expr> ::= <expr> Minus <term>")]
-        ExprMinus,
         #[rule("<expr> ::= <term>")]
-        ExprTerm,
+        Expr,
         #[rule("<term> ::= <term> Mul <num>")]
-        TermMul,
         #[rule("<term> ::= <term> Div <num>")]
-        TermDiv,
         #[rule("<term> ::= <num>")]
-        TermNum,
+        Term,
         #[rule("<num> ::= BracketL <expr> BracketR")]
-        NestedNum,
         #[rule("<num> ::= Num")]
         Num,
     }
diff --git a/crates/core/src/cfg/syntax.rs b/crates/core/src/cfg/syntax.rs
@@ -12,11 +12,18 @@ where
     type TokenSet: TokenSet<'a>;
 
     fn into_iter() -> impl Iterator<Item = Self>;
-    fn into_rule(&self) -> Rule<'a, Self::TokenSet>;
+    fn into_rules(&self) -> Vec<Rule<'a, Self::TokenSet>>;
 
     fn into_ruleset() -> RuleSet<'a, Self::TokenSet> {
         let rules = Self::into_iter()
-            .map(|elem| Self::into_rule(&elem))
+            .enumerate()
+            .flat_map(|(idx, elem)| {
+                let mut rules = Self::into_rules(&elem);
+                for rule in &mut rules {
+                    rule.id = idx;
+                }
+                rules
+            })
             .collect::<Vec<_>>();
 
         RuleSet::from(rules)
@@ -110,16 +117,12 @@ pub struct RuleSet<'a, T: TokenSet<'a>> {
 }
 
 impl<'a, T: TokenSet<'a>> From<Vec<Rule<'a, T>>> for RuleSet<'a, T> {
-    fn from(mut rules: Vec<Rule<'a, T>>) -> Self {
+    fn from(rules: Vec<Rule<'a, T>>) -> Self {
         let top = match &rules[0].lhs {
             RuleElem::NonTerm(s) => s.clone(),
             _ => unreachable!(),
         };
 
-        for (idx, rule) in rules.iter_mut().enumerate() {
-            rule.id = idx;
-        }
-
         RuleSet {
             top,
             rules,
@@ -307,7 +310,7 @@ mod test {
             )
         }
 
-        fn into_rule(&self) -> Rule<'a, Self::TokenSet> {
+        fn into_rules(&self) -> Vec<Rule<'a, Self::TokenSet>> {
             let expr_plus = Rule::from((
                 RuleElem::new_nonterm("expr"),
                 vec![
@@ -366,14 +369,14 @@ mod test {
             let fact_2_num = Rule::from((RuleElem::new_nonterm("fact"), vec![]));
 
             match self {
-                TestSyntax::ExprPlus => expr_plus,
-                TestSyntax::ExprMinus => expr_minus,
-                TestSyntax::Expr2Term => expr_2_term,
-                TestSyntax::TermMul => term_mul,
-                TestSyntax::TermDiv => term_div,
-                TestSyntax::Term2Fact => term_2_fact,
-                TestSyntax::Fact2Expr => fact_2_expr,
-                TestSyntax::Fact2Num => fact_2_num,
+                TestSyntax::ExprPlus => vec![expr_plus],
+                TestSyntax::ExprMinus => vec![expr_minus],
+                TestSyntax::Expr2Term => vec![expr_2_term],
+                TestSyntax::TermMul => vec![term_mul],
+                TestSyntax::TermDiv => vec![term_div],
+                TestSyntax::Term2Fact => vec![term_2_fact],
+                TestSyntax::Fact2Expr => vec![fact_2_expr],
+                TestSyntax::Fact2Num => vec![fact_2_num],
             }
         }
     }
diff --git a/crates/core_derive/src/impl/syntax.rs b/crates/core_derive/src/impl/syntax.rs
@@ -37,7 +37,7 @@ pub fn syntax_proc_macro_impl(ast: DeriveInput) -> TokenStream {
                 ].into_iter()
             }
 
-            fn into_rule(&self) -> Rule<'a, Self::TokenSet> {
+            fn into_rules(&self) -> Vec<Rule<'a, Self::TokenSet>> {
                 match self {
                     #( #enum_rule_table, )*
                     _ => unimplemented!(),
@@ -50,23 +50,23 @@ pub fn syntax_proc_macro_impl(ast: DeriveInput) -> TokenStream {
 struct VariantInfo<'a> {
     parent_ident: &'a Ident,
     self_ident: &'a Ident,
-    rule: Option<TokenStream>,
+    rules: Vec<TokenStream>,
 }
 
 impl<'a> VariantInfo<'a> {
     fn parse(parent_ident: &'a Ident, variant: &'a Variant) -> VariantInfo<'a> {
         let self_ident = &variant.ident;
 
-        let mut rule = None;
+        let mut rules = vec![];
         for attr in &variant.attrs {
             let attr = attr.parse_args::<LitStr>().unwrap().value();
-            rule = Some(Self::parse_rule(&attr));
+            rules.push(Self::parse_rule(&attr));
         }
 
         VariantInfo {
             parent_ident,
             self_ident,
-            rule,
+            rules,
         }
     }
 
@@ -102,9 +102,11 @@ impl<'a> VariantInfo<'a> {
 
     fn gen_ident_with_rule(&self) -> TokenStream {
         let ident = self.gen_ident();
-        match &self.rule {
-            Some(rule) => quote! { #ident => #rule },
-            None => quote! { unimplemented!() },
+        if self.rules.is_empty() {
+            quote! { #ident => unimplemented!() }
+        } else {
+            let rules = &self.rules;
+            quote! { #ident => vec![#(#rules),*] }
         }
     }
 }
diff --git a/examples/expr.rs b/examples/expr.rs
@@ -28,19 +28,14 @@ enum ExprTokenSet {
 #[derive(Debug, Clone, Copy, Syntax)]
 enum ExprSyntax {
     #[rule("<expr> ::= <expr> Plus <term>")]
-    ExprPlus,
     #[rule("<expr> ::= <expr> Minus <term>")]
-    ExprMinus,
     #[rule("<expr> ::= <term>")]
-    ExprTerm,
+    Expr,
     #[rule("<term> ::= <term> Mul <num>")]
-    TermMul,
     #[rule("<term> ::= <term> Div <num>")]
-    TermDiv,
     #[rule("<term> ::= <num>")]
-    TermNum,
+    Term,
     #[rule("<num> ::= BracketL <expr> BracketR")]
-    NestedNum,
     #[rule("<num> ::= Num")]
     Num,
 }
diff --git a/tests/derive.rs b/tests/derive.rs
@@ -23,25 +23,20 @@ enum TestTokenSet {
 #[derive(Debug, Clone, Copy, Syntax)]
 enum TestSyntax {
     #[rule("<expr> ::= <expr> Plus <term>")]
-    ExprPlus,
     #[rule("<expr> ::= <expr> Minus <term>")]
-    ExprMinus,
     #[rule("<expr> ::= <term>")]
-    ExprTerm,
+    Expr,
     #[rule("<term> ::= <term> Mul <num>")]
-    TermMul,
     #[rule("<term> ::= <term> Div <num>")]
-    TermDiv,
     #[rule("<term> ::= <num>")]
-    TermNum,
+    Term,
     #[rule("<num> ::= BracketL <expr> BracketR")]
-    NestedNum,
     #[rule("<num> ::= Num")]
     Num,
 }
 
 #[test]
 fn check_compile() {
     let _ = TestTokenSet::into_regex(&self::TestTokenSet::Plus);
-    let _ = TestSyntax::into_rule(&self::TestSyntax::ExprPlus);
+    let _ = TestSyntax::into_rules(&self::TestSyntax::Expr);
 }
diff --git a/tests/serde.rs b/tests/serde.rs
@@ -27,19 +27,14 @@ enum TestTokenSet {
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, Syntax)]
 enum TestSyntax {
     #[rule("<expr> ::= <expr> Plus <term>")]
-    ExprPlus,
     #[rule("<expr> ::= <expr> Minus <term>")]
-    ExprMinus,
     #[rule("<expr> ::= <term>")]
-    ExprTerm,
+    Expr,
     #[rule("<term> ::= <term> Mul <num>")]
-    TermMul,
     #[rule("<term> ::= <term> Div <num>")]
-    TermDiv,
     #[rule("<term> ::= <num>")]
-    TermNum,
+    Term,
     #[rule("<num> ::= BracketL <expr> BracketR")]
-    NestedNum,
     #[rule("<num> ::= Num")]
     Num,
 }

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ pub fn syntax_proc_macro_impl(ast: DeriveInput) -> TokenStream {`
`37`	`37`	`].into_iter()`
`38`	`38`	`}`
`39`	`39`
`40`		`- fn into_rule(&self) -> Rule<'a, Self::TokenSet> {`
	`40`	`+ fn into_rules(&self) -> Vec<Rule<'a, Self::TokenSet>> {`
`41`	`41`	`match self {`
`42`	`42`	`#( #enum_rule_table, )*`
`43`	`43`	`_ => unimplemented!(),`
`@@ -50,23 +50,23 @@ pub fn syntax_proc_macro_impl(ast: DeriveInput) -> TokenStream {`
`50`	`50`	`struct VariantInfo<'a> {`
`51`	`51`	`parent_ident: &'a Ident,`
`52`	`52`	`self_ident: &'a Ident,`
`53`		`- rule: Option<TokenStream>,`
	`53`	`+ rules: Vec<TokenStream>,`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`impl<'a> VariantInfo<'a> {`
`57`	`57`	`fn parse(parent_ident: &'a Ident, variant: &'a Variant) -> VariantInfo<'a> {`
`58`	`58`	`let self_ident = &variant.ident;`
`59`	`59`
`60`		`- let mut rule = None;`
	`60`	`+ let mut rules = vec![];`
`61`	`61`	`for attr in &variant.attrs {`
`62`	`62`	`let attr = attr.parse_args::<LitStr>().unwrap().value();`
`63`		`- rule = Some(Self::parse_rule(&attr));`
	`63`	`+ rules.push(Self::parse_rule(&attr));`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`VariantInfo {`
`67`	`67`	`parent_ident,`
`68`	`68`	`self_ident,`
`69`		`- rule,`
	`69`	`+ rules,`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`
`@@ -102,9 +102,11 @@ impl<'a> VariantInfo<'a> {`
`102`	`102`
`103`	`103`	`fn gen_ident_with_rule(&self) -> TokenStream {`
`104`	`104`	`let ident = self.gen_ident();`
`105`		`- match &self.rule {`
`106`		`- Some(rule) => quote! { #ident => #rule },`
`107`		`- None => quote! { unimplemented!() },`
	`105`	`+ if self.rules.is_empty() {`
	`106`	`+ quote! { #ident => unimplemented!() }`
	`107`	`+ } else {`
	`108`	`+ let rules = &self.rules;`
	`109`	`+ quote! { #ident => vec![#(#rules),*] }`
`108`	`110`	`}`
`109`	`111`	`}`
`110`	`112`	`}`