perf: Upgrade dprint-core and various perf improvements.

Almost twice as fast mostly due to changes in dprint-core.

Author: dsherret

Cargo.toml

@@ -24,10 +24,11 @@ panic = "abort"
 wasm = ["serde_json", "dprint-core/wasm"]
 
 [dependencies]
-dprint-core = { version = "0.33.1", features = ["formatting"] }
+dprint-core = { version = "0.34.0", features = ["formatting"] }
+fnv = "1.0.3"
 swc_common = "0.10.7"
 swc_ecmascript = { version = "0.16.0", features = ["parser"] }
-swc_ast_view = { version = "0.3.0", package = "dprint-swc-ecma-ast-view" }
+swc_ast_view = { version = "0.3.1", package = "dprint-swc-ecma-ast-view" }
 serde = { version = "1.0.118", features = ["derive"] }
 serde_json = { version = "1.0", optional = true }
 

src/parsing/parser.rs

@@ -1,4 +1,3 @@
-use std::collections::HashMap;
 use std::rc::Rc;
 use dprint_core::formatting::*;
 use dprint_core::formatting::{parser_helpers::*,condition_resolvers, conditions::*};
@@ -4848,7 +4847,7 @@ fn parse_statements<'a>(inner_span: Span, stmts: Vec<Node<'a>>, context: &mut Co
 
         let nodes_len = stmt_group.nodes.len();
         let mut parsed_nodes = Vec::with_capacity(nodes_len);
-        let mut parsed_line_separators = HashMap::with_capacity(if nodes_len == 0 { 0 } else { nodes_len - 1 });
+        let mut parsed_line_separators = utils::VecMap::with_capacity(nodes_len);
         let sorter = get_node_sorter(stmt_group.kind, context);
         let sorted_indexes = match sorter {
             Some(sorter) => Some(get_sorted_indexes(stmt_group.nodes.iter().map(|n| Some(n)), sorter, context)),
@@ -4897,7 +4896,7 @@ fn parse_statements<'a>(inner_span: Span, stmts: Vec<Node<'a>>, context: &mut Co
 
         // Now combine everything
         for (i, parsed_node) in parsed_nodes.into_iter().enumerate() {
-            if let Some(parsed_separator) = parsed_line_separators.remove(&i) {
+            if let Some(parsed_separator) = parsed_line_separators.remove(i) {
                 items.extend(parsed_separator);
             }
             items.extend(parsed_node);
@@ -5360,7 +5359,7 @@ fn parse_separated_values_with_result<'a>(
 
         for (i, value) in nodes.into_iter().enumerate() {
             let node_index = match &sorted_indexes {
-                Some(old_to_new_index) => *old_to_new_index.get(&i).unwrap(),
+                Some(old_to_new_index) => *old_to_new_index.get(i).unwrap(),
                 None => i,
             };
             let (allow_inline_multi_line, allow_inline_single_line) = if let Some(value) = &value {
@@ -5412,10 +5411,10 @@ fn get_sorted_indexes<'a: 'b, 'b>(
     nodes: impl Iterator<Item=Option<&'b Node<'a>>>,
     sorter: Box<dyn Fn((usize, Option<&Node<'a>>), (usize, Option<&Node<'a>>), &Module<'a>) -> std::cmp::Ordering>,
     context: &mut Context<'a>,
-) -> HashMap<usize, usize> {
+) -> utils::VecMap<usize> {
     let mut nodes_with_indexes = nodes.enumerate().collect::<Vec<_>>();
     nodes_with_indexes.sort_unstable_by(|a, b| sorter((a.0, a.1), (b.0, b.1), context.module));
-    let mut old_to_new_index = HashMap::new();
+    let mut old_to_new_index = utils::VecMap::with_capacity(nodes_with_indexes.len());
 
     for (new_index, old_index) in nodes_with_indexes.into_iter().map(|(index, _)| index).enumerate() {
         old_to_new_index.insert(old_index, new_index);
@@ -5424,14 +5423,14 @@ fn get_sorted_indexes<'a: 'b, 'b>(
     old_to_new_index
 }
 
-fn sort_by_sorted_indexes<T>(items: Vec<T>, sorted_indexes: HashMap<usize, usize>) -> Vec<T> {
+fn sort_by_sorted_indexes<T>(items: Vec<T>, sorted_indexes: utils::VecMap<usize>) -> Vec<T> {
     let mut sorted_items = Vec::with_capacity(items.len());
     for _ in 0..items.len() {
         sorted_items.push(None);
     }
 
     for (i, parsed_node) in items.into_iter().enumerate() {
-        sorted_items[*sorted_indexes.get(&i).unwrap_or(&i)] = Some(parsed_node);
+        sorted_items[*sorted_indexes.get(i).unwrap_or(&i)] = Some(parsed_node);
     }
 
     sorted_items.into_iter().map(|x| x.unwrap()).collect()

src/parsing/parser_types.rs

@@ -1,7 +1,7 @@
-use std::collections::{HashSet, HashMap};
 use dprint_core::formatting::{Info, ConditionReference};
 use swc_common::SourceFile;
 use swc_ast_view::*;
+use fnv::{FnvHashMap, FnvHashSet};
 
 use super::*;
 use crate::configuration::*;
@@ -14,10 +14,10 @@ pub struct Context<'a> {
     pub token_finder: TokenFinder<'a>,
     pub current_node: Node<'a>,
     pub parent_stack: Stack<Node<'a>>,
-    handled_comments: HashSet<BytePos>,
+    handled_comments: FnvHashSet<BytePos>,
     pub info: &'a SourceFile,
-    stored_infos: HashMap<(BytePos, BytePos), Info>,
-    stored_info_ranges: HashMap<(BytePos, BytePos), (Info, Info)>,
+    stored_infos: FnvHashMap<(BytePos, BytePos), Info>,
+    stored_info_ranges: FnvHashMap<(BytePos, BytePos), (Info, Info)>,
     pub end_statement_or_member_infos: Stack<Info>,
     before_comments_start_info_stack: Stack<(Span, Info)>,
     if_stmt_last_brace_condition_ref: Option<ConditionReference>,
@@ -41,10 +41,10 @@ impl<'a> Context<'a> {
             token_finder: TokenFinder::new(module),
             current_node,
             parent_stack: Stack::new(),
-            handled_comments: HashSet::new(),
+            handled_comments: FnvHashSet::default(),
             info,
-            stored_infos: HashMap::new(),
-            stored_info_ranges: HashMap::new(),
+            stored_infos: FnvHashMap::default(),
+            stored_info_ranges: FnvHashMap::default(),
             end_statement_or_member_infos: Stack::new(),
             before_comments_start_info_stack: Stack::new(),
             if_stmt_last_brace_condition_ref: None,

src/utils/mod.rs

@@ -2,8 +2,10 @@ mod char_iterator;
 mod is_prefix_semi_colon_insertion_char;
 mod stack;
 mod string_utils;
+mod vec_map;
 
 pub use char_iterator::*;
 pub use is_prefix_semi_colon_insertion_char::*;
 pub use stack::*;
 pub use string_utils::*;
+pub use vec_map::*;

src/utils/vec_map.rs

@@ -0,0 +1,29 @@
+/// A faster map for when the mapping is being done over keys going from 0..n
+pub struct VecMap<T> {
+    inner: Vec<Option<T>>,
+}
+
+impl<T> VecMap<T> {
+    pub fn with_capacity(capacity: usize) -> VecMap<T> {
+        let mut inner = Vec::with_capacity(capacity);
+        for _ in 0..capacity {
+            inner.push(None);
+        }
+
+        VecMap {
+            inner
+        }
+    }
+
+    pub fn insert(&mut self, index: usize, value: T) {
+        self.inner[index] = Some(value);
+    }
+
+    pub fn get(&self, index: usize) -> Option<&T> {
+        self.inner.get(index).map(|value| value.as_ref()).flatten()
+    }
+
+    pub fn remove(&mut self, index: usize) -> Option<T> {
+        self.inner.get_mut(index).map(|value| value.take()).flatten()
+    }
+}