#29 fix clippy command in github actions and resolve clippy warning (#30)

* fix: clippy warning

* fix: clippy command

* fix: doc test

* fix: clippy

Author: tanzaku

.github/workflows/rust.yml

@@ -24,7 +24,11 @@ jobs:
         run: cargo bench
       - name: Run benchmarks with features
         run: cargo bench --features regex-match
-      - name: clippy
-        uses: actions-rs/clippy-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Clippy (automata)
+        run: cargo clippy -p automata -- -D warnings
+      - name: Clippy (lexer-generator)
+        run: cargo clippy -p lexer-generator -- -D warnings
+      - name: Clippy (parser-generator)
+        run: cargo clippy -p parser-generator -- -D warnings
+      - name: Clippy (postgresql-cst-parser)
+        run: cargo clippy -p postgresql-cst-parser -- -D warnings

crates/automata/src/dfa.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::mutable_key_type)]
 use std::collections::{BTreeMap, BTreeSet};
 
 use crate::nfa::{NFAState, Transition, collect_epsilon_closure};
@@ -21,7 +22,7 @@ pub struct DFA {
     pub states: Vec<DFAState>,
 }
 
-impl<'a> DFA {
+impl DFA {
     pub fn match_bytes(&self, bs: &[u8]) -> Option<u32> {
         let mut state = 0;
 

crates/automata/src/lib.rs

@@ -127,7 +127,7 @@ pub fn build_nfa_from_regex_node<'a>(
         RegexpNode::Reference(name) => {
             let regexp_node = named_pattern_definitions
                 .get(name)
-                .expect(&format!("Referenced pattern '{}' not found", name));
+                .unwrap_or_else(|| panic!("Referenced pattern '{}' not found", name));
 
             let node_nfa @ NFAFragment {
                 start_state: node_start,
@@ -150,7 +150,7 @@ pub fn build_nfa_from_regex_node<'a>(
                     accept_state: node_accept,
                 } = NFAFragment::new(nfa);
 
-                build_nfa_from_regex_node(nfa, &node_nfa, &*node, named_pattern_definitions);
+                build_nfa_from_regex_node(nfa, &node_nfa, node, named_pattern_definitions);
 
                 state.add_transition(node_start, Transition::Epsilon);
                 state = node_accept;

crates/automata/src/nfa.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::mutable_key_type)]
 use std::{
     cell::{Cell, RefCell},
     collections::{BTreeMap, BTreeSet},
@@ -18,6 +19,7 @@ pub enum Transition {
 
 /// Represents a state in a Non-deterministic Finite Automaton.
 /// States are connected by transitions and can accept input.
+#[allow(clippy::mutable_key_type)]
 #[derive(Debug, Clone, Eq)]
 pub struct NFAState<'a> {
     pub state_id: usize,
@@ -37,7 +39,7 @@ impl PartialEq for NFAState<'_> {
 
 impl PartialOrd for NFAState<'_> {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        self.state_id.partial_cmp(&other.state_id)
+        Some(self.state_id.cmp(&other.state_id))
     }
 }
 
@@ -83,7 +85,7 @@ pub fn collect_epsilon_closure<'a>(
     let mut accepted_lexer_rule_id = None;
 
     {
-        let id = s.accept_lexer_rule_id.borrow().clone();
+        let id = *s.accept_lexer_rule_id.borrow();
         if accepted_lexer_rule_id.unwrap_or(!0) > id.unwrap_or(!0) {
             accepted_lexer_rule_id = id;
         }
@@ -95,7 +97,7 @@ pub fn collect_epsilon_closure<'a>(
                 if epsilon_closure.insert(new_state) {
                     candidate.push(new_state);
 
-                    let id = new_state.accept_lexer_rule_id.borrow().clone();
+                    let id = *new_state.accept_lexer_rule_id.borrow();
                     if accepted_lexer_rule_id.unwrap_or(!0) > id.unwrap_or(!0) {
                         accepted_lexer_rule_id = id;
                     }
@@ -175,6 +177,12 @@ impl<'a> NFA<'a> {
     }
 }
 
+impl Default for NFA<'_> {
+    fn default() -> Self {
+        NFA::new()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/automata/src/regexp.rs

@@ -100,9 +100,9 @@ impl RegexpParser {
                     }
 
                     let d = match c {
-                        b'0'..=b'9' => c as u8 - b'0',
-                        b'a'..=b'f' => c as u8 - b'a' + 10,
-                        b'A'..=b'F' => c as u8 - b'A' + 10,
+                        b'0'..=b'9' => c - b'0',
+                        b'a'..=b'f' => c - b'a' + 10,
+                        b'A'..=b'F' => c - b'A' + 10,
                         _ => unreachable!(),
                     };
 
@@ -114,7 +114,7 @@ impl RegexpParser {
             }
             // If no format specified, treat as octal number
             b'0'..=b'9' => {
-                let mut v = c as u8 - b'0';
+                let mut v = c - b'0';
 
                 while self.index < self.bytes.len() {
                     let c = self.bytes[self.index];
@@ -123,13 +123,13 @@ impl RegexpParser {
                         break;
                     }
 
-                    v = v * 8 + (c as u8 - b'0');
+                    v = v * 8 + (c - b'0');
                     self.index += 1;
                 }
 
                 v
             }
-            _ => c as u8,
+            _ => c,
         }
     }
 
@@ -163,7 +163,7 @@ impl RegexpParser {
                     let bs = nodes
                         .into_iter()
                         .map(|node| match node {
-                            RegexpNode::Char(c) => c as u8,
+                            RegexpNode::Char(c) => c,
                             _ => panic!(),
                         })
                         .collect::<Vec<_>>();
@@ -181,7 +181,7 @@ impl RegexpParser {
                 _ => {
                     self.index += 1;
                     is_minus = c == b'-';
-                    nodes.push(RegexpNode::Char(c as u8))
+                    nodes.push(RegexpNode::Char(c))
                 }
             }
 
@@ -210,7 +210,7 @@ impl RegexpParser {
                 break;
             }
 
-            nodes.push(RegexpNode::Char(c as u8));
+            nodes.push(RegexpNode::Char(c));
         }
 
         RegexpNode::concat(nodes)
@@ -310,7 +310,7 @@ impl RegexpParser {
             b']' | b')' | b'}' => unreachable!(),
             _ => {
                 self.index += 1;
-                RegexpNode::Char(c as u8)
+                RegexpNode::Char(c)
             }
         }
     }
@@ -354,6 +354,12 @@ impl RegexpParser {
     }
 }
 
+impl Default for RegexpParser {
+    fn default() -> Self {
+        RegexpParser::new()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/lexer-generator/src/flex_file.rs

@@ -53,8 +53,8 @@ fn parse_pattern_actions(
         return None;
     }
 
-    if line.starts_with("<<EOF>>") {
-        let rest = line["<<EOF>>".len()..].to_owned();
+    if let Some(stripped) = line.strip_prefix("<<EOF>>") {
+        let rest = stripped.to_owned();
         let actions = parse_actions(rest, it);
         return Some(("<<EOF>>".to_owned(), actions));
     }
@@ -110,7 +110,7 @@ fn parse_rules(states: Vec<String>, it: &mut impl Iterator<Item = String>) -> Ve
 }
 
 fn skip_c_source(it: &mut impl Iterator<Item = String>) {
-    while let Some(line) = it.next() {
+    for line in it {
         if line == "%}" {
             break;
         }
@@ -136,8 +136,8 @@ pub fn parse_flex_file(s: impl AsRef<str>) -> FlexFile {
             continue;
         }
 
-        if line.starts_with("%x ") {
-            flex_file.all_states.push(line[3..].to_owned());
+        if let Some(rest) = line.strip_prefix("%x ") {
+            flex_file.all_states.push(rest.to_owned());
             continue;
         }
 
@@ -156,9 +156,9 @@ pub fn parse_flex_file(s: impl AsRef<str>) -> FlexFile {
 
     flex_file.rules = parse_rules(Vec::new(), &mut it);
 
-    while let Some(line) = it.next() {
+    for line in it {
         flex_file.rest_code += &line;
-        flex_file.rest_code += &"\n";
+        flex_file.rest_code += "\n";
     }
 
     flex_file

crates/lexer-generator/src/lexer_generator.rs

@@ -33,16 +33,12 @@ fn construct_actions(flex_file: &FlexFile) -> String {
 
             // If the action is |, the subsequent rule will be executed
             if rule.actions.trim() == "|" {
-                res.push(format!(
-                    r#"RuleKind::{kind}|"#,
-                    kind = format!("{}{}", s, e)
-                ));
+                res.push(format!(r#"RuleKind::{s}{e}|"#));
             } else {
                 res.push(format!(
-                    r#"RuleKind::{kind} => {{
+                    r#"RuleKind::{s}{e} => {{
                     {actions}
                 }}"#,
-                    kind = format!("{}{}", s, e),
                     actions = rule.actions
                 ));
             }
@@ -70,12 +66,13 @@ fn construct_pattern_actions_by_index(flex_file: &FlexFile) -> String {
     }
 
     // どのルールにもマッチしなかったときの値
-    res.push(format!(r#"255 => {{}}"#));
-    res.push(format!(
+    res.push(r#"255 => {{}}"#.to_string());
+    res.push(
         r#"_ => {{
             unreachable!()
         }}"#
-    ));
+        .to_string(),
+    );
 
     res.join("\n")
 }
@@ -129,7 +126,7 @@ fn extract_rule_pattern(flex_file: &FlexFile, pattern: &str) -> (String, bool) {
 
     // Expand {xxx} to actual regular expression patterns
     let replaced = p
-        .replace_all(&pattern, |caps: &regex::Captures| {
+        .replace_all(pattern, |caps: &regex::Captures| {
             let name = caps.get(1).unwrap().as_str();
 
             // Check if xxx in {xxx} is defined
@@ -163,13 +160,12 @@ fn construct_rule_defs(flex_file: &FlexFile) -> String {
                 Rule {{
                     state: State::{s},
                     pattern: regex::bytes::Regex::new(r#"(?-u)^({pattern})"#).unwrap(),
-                    kind: RuleKind::{rule_kind},
+                    kind: RuleKind::{s}{e},
                     eof: {eof},
                 }}"###,
                 original_pattern = rule.pattern,
                 pattern = pattern,
                 eof = eof,
-                rule_kind = format!("{}{}", s, e),
             ));
         }
     }

crates/parser-generator/src/parser_generator.rs

@@ -72,7 +72,7 @@ fn compress_action_table(
     fn find_most_common_action(
         uncompressed_action_table: &[i16],
         state_index: usize,
-        terminal_symbols: &Vec<Component>,
+        terminal_symbols: &[Component],
     ) -> i16 {
         let mut cnt: BTreeMap<i16, u16> = BTreeMap::new();
         for j in 0..terminal_symbols.len() {
@@ -116,19 +116,14 @@ fn compress_action_table(
                         ok = false;
                         break;
                     }
-                } else {
-                    if index_check[i + j] == j as i16 {
-                        if compressed_values[i + j] != a {
-                            ok = false;
-                            break;
-                        }
-                    } else if index_check[i + j] != UNUSED_ENTRY_CODE {
-                        ok = false;
-                        break;
-                    } else if offset_used[i] {
+                } else if index_check[i + j] == j as i16 {
+                    if compressed_values[i + j] != a {
                         ok = false;
                         break;
                     }
+                } else if index_check[i + j] != UNUSED_ENTRY_CODE || offset_used[i] {
+                    ok = false;
+                    break;
                 }
             }
 
@@ -154,7 +149,7 @@ fn compress_action_table(
     let max_table_index = *state_to_offset.iter().max().unwrap() as usize + terminal_symbols.len();
 
     let info = CompressedParserTable {
-        state_to_offset: state_to_offset,
+        state_to_offset,
         compressed_values: compressed_values[..max_table_index].to_vec(),
         index_check: index_check[..max_table_index].to_vec(),
     };
@@ -199,19 +194,14 @@ fn compress_goto_table(
                         ok = false;
                         break;
                     }
-                } else {
-                    if index_check[i + j] == j as i16 {
-                        if compressed_values[i + j] != a {
-                            ok = false;
-                            break;
-                        }
-                    } else if index_check[i + j] != UNUSED_ENTRY_CODE {
-                        ok = false;
-                        break;
-                    } else if offset_used[i] {
+                } else if index_check[i + j] == j as i16 {
+                    if compressed_values[i + j] != a {
                         ok = false;
                         break;
                     }
+                } else if index_check[i + j] != UNUSED_ENTRY_CODE || offset_used[i] {
+                    ok = false;
+                    break;
                 }
             }
 
@@ -236,13 +226,11 @@ fn compress_goto_table(
     let max_table_index =
         *state_to_offset.iter().max().unwrap() as usize + non_terminal_symbols.len();
 
-    let info = CompressedParserTable {
-        state_to_offset: state_to_offset,
+    CompressedParserTable {
+        state_to_offset,
         compressed_values: compressed_values[..max_table_index].to_vec(),
         index_check: index_check[..max_table_index].to_vec(),
-    };
-
-    info
+    }
 }
 
 fn generate_parser_source_code(
@@ -259,8 +247,8 @@ fn generate_parser_source_code(
             .join(",")
     }
 
-    let (action_table_info, def_rules) = compress_action_table(lalr, &terminal_symbols);
-    let goto_table_info = compress_goto_table(lalr, &non_terminal_symbols);
+    let (action_table_info, def_rules) = compress_action_table(lalr, terminal_symbols);
+    let goto_table_info = compress_goto_table(lalr, non_terminal_symbols);
 
     let terminal_symbols_with_comment = terminal_symbols
         .iter()
@@ -378,9 +366,9 @@ fn generate_parser_source_code(
 }
 
 fn generate_syntax_kinds_source_code(
-    terminal_symbols: &Vec<Component>,
-    non_terminal_symbols: &Vec<Component>,
-    comments: &Vec<Component>,
+    terminal_symbols: &[Component],
+    non_terminal_symbols: &[Component],
+    comments: &[Component],
 ) {
     let mut kinds = Vec::new();
     for c in terminal_symbols