style: format imports

Author: amaanq

cli/benches/benchmark.rs

@@ -1,9 +1,14 @@
+use std::{
+    collections::BTreeMap,
+    env, fs,
+    path::{Path, PathBuf},
+    str,
+    time::Instant,
+    usize,
+};
+
 use anyhow::Context;
 use lazy_static::lazy_static;
-use std::collections::BTreeMap;
-use std::path::{Path, PathBuf};
-use std::time::Instant;
-use std::{env, fs, str, usize};
 use tree_sitter::{Language, Parser, Query};
 use tree_sitter_loader::{CompileConfig, Loader};
 

cli/config/src/lib.rs

@@ -1,10 +1,10 @@
 #![doc = include_str!("../README.md")]
 
+use std::{env, fs, path::PathBuf};
+
 use anyhow::{anyhow, Context, Result};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use std::path::PathBuf;
-use std::{env, fs};
 
 /// Holds the contents of tree-sitter's configuration file.
 ///

cli/loader/src/lib.rs

@@ -1,14 +1,18 @@
 #![doc = include_str!("../README.md")]
 
-use std::collections::HashMap;
-use std::ffi::{OsStr, OsString};
-use std::io::{BufRead, BufReader};
-use std::ops::Range;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-use std::sync::Mutex;
-use std::time::SystemTime;
-use std::{env, fs, mem};
+use std::{
+    collections::HashMap,
+    env,
+    ffi::{OsStr, OsString},
+    fs,
+    io::{BufRead, BufReader},
+    mem,
+    ops::Range,
+    path::{Path, PathBuf},
+    process::Command,
+    sync::Mutex,
+    time::SystemTime,
+};
 
 use anyhow::{anyhow, Context, Error, Result};
 use fs4::FileExt;

cli/src/generate/build_tables/build_lex_table.rs

@@ -1,14 +1,18 @@
-use super::coincident_tokens::CoincidentTokenIndex;
-use super::token_conflicts::TokenConflictMap;
-use crate::generate::dedup::split_state_id_groups;
-use crate::generate::grammars::{LexicalGrammar, SyntaxGrammar};
-use crate::generate::nfa::NfaCursor;
-use crate::generate::rules::{Symbol, TokenSet};
-use crate::generate::tables::{AdvanceAction, LexState, LexTable, ParseStateId, ParseTable};
+use std::{
+    collections::{hash_map::Entry, HashMap, VecDeque},
+    mem,
+};
+
 use log::info;
-use std::collections::hash_map::Entry;
-use std::collections::{HashMap, VecDeque};
-use std::mem;
+
+use super::{coincident_tokens::CoincidentTokenIndex, token_conflicts::TokenConflictMap};
+use crate::generate::{
+    dedup::split_state_id_groups,
+    grammars::{LexicalGrammar, SyntaxGrammar},
+    nfa::NfaCursor,
+    rules::{Symbol, TokenSet},
+    tables::{AdvanceAction, LexState, LexTable, ParseStateId, ParseTable},
+};
 
 pub fn build_lex_table(
     parse_table: &mut ParseTable,

cli/src/generate/build_tables/build_parse_table.rs

@@ -1,25 +1,30 @@
-use super::item::{ParseItem, ParseItemSet, ParseItemSetCore};
-use super::item_set_builder::ParseItemSetBuilder;
-use crate::generate::grammars::PrecedenceEntry;
-use crate::generate::grammars::{
-    InlinedProductionMap, LexicalGrammar, SyntaxGrammar, VariableType,
+use std::{
+    cmp::Ordering,
+    collections::{BTreeMap, HashMap, HashSet, VecDeque},
+    fmt::Write,
+    hash::BuildHasherDefault,
 };
-use crate::generate::node_types::VariableInfo;
-use crate::generate::rules::{Associativity, Precedence, Symbol, SymbolType, TokenSet};
-use crate::generate::tables::{
-    FieldLocation, GotoAction, ParseAction, ParseState, ParseStateId, ParseTable, ParseTableEntry,
-    ProductionInfo, ProductionInfoId,
-};
-use anyhow::{anyhow, Result};
-use std::cmp::Ordering;
-use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
-use std::fmt::Write;
-use std::hash::BuildHasherDefault;
-use std::u32;
 
+use anyhow::{anyhow, Result};
 use indexmap::{map::Entry, IndexMap};
 use rustc_hash::FxHasher;
 
+use super::{
+    item::{ParseItem, ParseItemSet, ParseItemSetCore},
+    item_set_builder::ParseItemSetBuilder,
+};
+use crate::generate::{
+    grammars::{
+        InlinedProductionMap, LexicalGrammar, PrecedenceEntry, SyntaxGrammar, VariableType,
+    },
+    node_types::VariableInfo,
+    rules::{Associativity, Precedence, Symbol, SymbolType, TokenSet},
+    tables::{
+        FieldLocation, GotoAction, ParseAction, ParseState, ParseStateId, ParseTable,
+        ParseTableEntry, ProductionInfo, ProductionInfoId,
+    },
+};
+
 // For conflict reporting, each parse state is associated with an example
 // sequence of symbols that could lead to that parse state.
 type SymbolSequence = Vec<Symbol>;

cli/src/generate/build_tables/coincident_tokens.rs

@@ -1,8 +1,11 @@
-use crate::generate::grammars::LexicalGrammar;
-use crate::generate::rules::Symbol;
-use crate::generate::tables::{ParseStateId, ParseTable};
 use std::fmt;
 
+use crate::generate::{
+    grammars::LexicalGrammar,
+    rules::Symbol,
+    tables::{ParseStateId, ParseTable},
+};
+
 pub struct CoincidentTokenIndex<'a> {
     entries: Vec<Vec<ParseStateId>>,
     grammar: &'a LexicalGrammar,

cli/src/generate/build_tables/item.rs

@@ -1,10 +1,15 @@
-use crate::generate::grammars::{LexicalGrammar, Production, ProductionStep, SyntaxGrammar};
-use crate::generate::rules::{Associativity, Precedence, Symbol, SymbolType, TokenSet};
+use std::{
+    cmp::Ordering,
+    fmt,
+    hash::{Hash, Hasher},
+};
+
 use lazy_static::lazy_static;
-use std::cmp::Ordering;
-use std::fmt;
-use std::hash::{Hash, Hasher};
-use std::u32;
+
+use crate::generate::{
+    grammars::{LexicalGrammar, Production, ProductionStep, SyntaxGrammar},
+    rules::{Associativity, Precedence, Symbol, SymbolType, TokenSet},
+};
 
 lazy_static! {
     static ref START_PRODUCTION: Production = Production {

cli/src/generate/build_tables/item_set_builder.rs

@@ -1,8 +1,13 @@
+use std::{
+    collections::{HashMap, HashSet},
+    fmt,
+};
+
 use super::item::{ParseItem, ParseItemDisplay, ParseItemSet, TokenSetDisplay};
-use crate::generate::grammars::{InlinedProductionMap, LexicalGrammar, SyntaxGrammar};
-use crate::generate::rules::{Symbol, SymbolType, TokenSet};
-use std::collections::{HashMap, HashSet};
-use std::fmt;
+use crate::generate::{
+    grammars::{InlinedProductionMap, LexicalGrammar, SyntaxGrammar},
+    rules::{Symbol, SymbolType, TokenSet},
+};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 struct TransitiveClosureAddition<'a> {

cli/src/generate/build_tables/minimize_parse_table.rs

@@ -1,13 +1,17 @@
-use super::token_conflicts::TokenConflictMap;
-use crate::generate::dedup::split_state_id_groups;
-use crate::generate::grammars::{LexicalGrammar, SyntaxGrammar, VariableType};
-use crate::generate::rules::{AliasMap, Symbol, TokenSet};
-use crate::generate::tables::{
-    GotoAction, ParseAction, ParseState, ParseStateId, ParseTable, ParseTableEntry,
+use std::{
+    collections::{HashMap, HashSet},
+    mem,
 };
+
 use log::info;
-use std::collections::{HashMap, HashSet};
-use std::mem;
+
+use super::token_conflicts::TokenConflictMap;
+use crate::generate::{
+    dedup::split_state_id_groups,
+    grammars::{LexicalGrammar, SyntaxGrammar, VariableType},
+    rules::{AliasMap, Symbol, TokenSet},
+    tables::{GotoAction, ParseAction, ParseState, ParseStateId, ParseTable, ParseTableEntry},
+};
 
 pub fn minimize_parse_table(
     parse_table: &mut ParseTable,

cli/src/generate/build_tables/mod.rs

@@ -6,19 +6,25 @@ mod item_set_builder;
 mod minimize_parse_table;
 mod token_conflicts;
 
-use self::build_lex_table::build_lex_table;
-use self::build_parse_table::{build_parse_table, ParseStateInfo};
-use self::coincident_tokens::CoincidentTokenIndex;
-use self::minimize_parse_table::minimize_parse_table;
-use self::token_conflicts::TokenConflictMap;
-use crate::generate::grammars::{InlinedProductionMap, LexicalGrammar, SyntaxGrammar};
-use crate::generate::nfa::NfaCursor;
-use crate::generate::node_types::VariableInfo;
-use crate::generate::rules::{AliasMap, Symbol, SymbolType, TokenSet};
-use crate::generate::tables::{LexTable, ParseAction, ParseTable, ParseTableEntry};
+use std::collections::{BTreeSet, HashMap};
+
 use anyhow::Result;
 use log::info;
-use std::collections::{BTreeSet, HashMap};
+
+use self::{
+    build_lex_table::build_lex_table,
+    build_parse_table::{build_parse_table, ParseStateInfo},
+    coincident_tokens::CoincidentTokenIndex,
+    minimize_parse_table::minimize_parse_table,
+    token_conflicts::TokenConflictMap,
+};
+use crate::generate::{
+    grammars::{InlinedProductionMap, LexicalGrammar, SyntaxGrammar},
+    nfa::NfaCursor,
+    node_types::VariableInfo,
+    rules::{AliasMap, Symbol, SymbolType, TokenSet},
+    tables::{LexTable, ParseAction, ParseTable, ParseTableEntry},
+};
 
 pub fn build_tables(
     syntax_grammar: &SyntaxGrammar,