Merge #1648

1648: Optimize parsing a little r=lnicola a=lnicola

This is the change from https://github.com/rust-analyzer/rust-analyzer/issues/1643#issuecomment-517979911. In the long run we should probably take a different approach, but until then this provides a decent speed-up (10.5s vs 11.5s according to `ra_cli analysis-stats`.

EDIT: Does the profiling part make sense? I'm not sure if all parsing happens before the type inference begins or it's lazy.

Co-authored-by: Laurențiu Nicola <[email protected]>
Co-authored-by: Laurențiu Nicola <[email protected]>

2 files changed, 40 insertions, 20 deletions

diff --git a/crates/ra_cli/src/analysis_stats.rs b/crates/ra_cli/src/analysis_stats.rs
index 403aab352..7e7e6c073 100644
--- a/crates/ra_cli/src/analysis_stats.rs
+++ b/crates/ra_cli/src/analysis_stats.rs
@@ -52,6 +52,9 @@ pub fn run(verbose: bool, memory_usage: bool, path: &Path, only: Option<&str>) -
     println!("Total modules found: {}", visited_modules.len());
     println!("Total declarations: {}", num_decls);
     println!("Total functions: {}", funcs.len());
+    println!("Item Collection: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage());
+
+    let inference_time = Instant::now();
     let bar = indicatif::ProgressBar::with_draw_target(
         funcs.len() as u64,
         indicatif::ProgressDrawTarget::stderr_nohz(),
@@ -112,7 +115,8 @@ pub fn run(verbose: bool, memory_usage: bool, path: &Path, only: Option<&str>) -
         num_exprs_partially_unknown,
         (num_exprs_partially_unknown * 100 / num_exprs)
     );
-    println!("Analysis: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage());
+    println!("Inference: {:?}, {}", inference_time.elapsed(), ra_prof::memory_usage());
+    println!("Total: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage());
 
     if memory_usage {
         drop(db);
diff --git a/crates/ra_parser/src/parser.rs b/crates/ra_parser/src/parser.rs
index 159ed50df..393586561 100644
--- a/crates/ra_parser/src/parser.rs
+++ b/crates/ra_parser/src/parser.rs
@@ -6,7 +6,7 @@ use crate::{
     event::Event,
     ParseError,
     SyntaxKind::{self, EOF, ERROR, TOMBSTONE},
-    TokenSet, TokenSource, T,
+    Token, TokenSet, TokenSource, T,
 };
 
 /// `Parser` struct provides the low-level API for
@@ -87,8 +87,9 @@ impl<'t> Parser<'t> {
         let mut i = 0;
 
         loop {
-            let mut kind = self.token_source.lookahead_nth(i).kind;
-            if let Some((composited, step)) = self.is_composite(kind, i) {
+            let token = self.token_source.lookahead_nth(i);
+            let mut kind = token.kind;
+            if let Some((composited, step)) = self.is_composite(token, i) {
                 kind = composited;
                 i += step;
             } else {
@@ -250,32 +251,47 @@ impl<'t> Parser<'t> {
     }
 
     /// helper function for check if it is composite.
-    fn is_composite(&self, kind: SyntaxKind, n: usize) -> Option<(SyntaxKind, usize)> {
+    fn is_composite(&self, first: Token, n: usize) -> Option<(SyntaxKind, usize)> {
         // We assume the dollars will not occuried between
         // mult-byte tokens
 
-        let first = self.token_source.lookahead_nth(n);
+        let jn1 = first.is_jointed_to_next;
+        if !jn1 && first.kind != T![-] {
+            return None;
+        }
+
         let second = self.token_source.lookahead_nth(n + 1);
+        if first.kind == T![-] && second.kind == T![>] {
+            return Some((T![->], 2));
+        }
+        if !jn1 {
+            return None;
+        }
+
+        match (first.kind, second.kind) {
+            (T![:], T![:]) => return Some((T![::], 2)),
+            (T![=], T![=]) => return Some((T![==], 2)),
+            (T![=], T![>]) => return Some((T![=>], 2)),
+            (T![!], T![=]) => return Some((T![!=], 2)),
+            _ => {}
+        }
+
+        if first.kind != T![.] || second.kind != T![.] {
+            return None;
+        }
+
         let third = self.token_source.lookahead_nth(n + 2);
 
-        let jn1 = first.is_jointed_to_next;
-        let la2 = second.kind;
         let jn2 = second.is_jointed_to_next;
         let la3 = third.kind;
 
-        match kind {
-            T![.] if jn1 && la2 == T![.] && jn2 && la3 == T![.] => Some((T![...], 3)),
-            T![.] if jn1 && la2 == T![.] && la3 == T![=] => Some((T![..=], 3)),
-            T![.] if jn1 && la2 == T![.] => Some((T![..], 2)),
-
-            T![:] if jn1 && la2 == T![:] => Some((T![::], 2)),
-            T![=] if jn1 && la2 == T![=] => Some((T![==], 2)),
-            T![=] if jn1 && la2 == T![>] => Some((T![=>], 2)),
-
-            T![!] if jn1 && la2 == T![=] => Some((T![!=], 2)),
-            T![-] if la2 == T![>] => Some((T![->], 2)),
-            _ => None,
+        if jn2 && la3 == T![.] {
+            return Some((T![...], 3));
+        }
+        if la3 == T![=] {
+            return Some((T![..=], 3));
         }
+        return Some((T![..], 2));
     }
 
     fn eat_dollars(&mut self) {