5 files changed, 67 insertions, 66 deletions

diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 49696ce75..670f04578 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -13,7 +13,7 @@ doctest = false
 [dependencies]
 itertools = "0.9.0"
 rowan = "0.10.0"
-rustc_lexer = { version = "666.0.0", package = "rustc-ap-rustc_lexer" }
+rustc_lexer = { version = "669.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.5.1"
 once_cell = "1.3.1"
@@ -31,4 +31,6 @@ serde = { version = "1.0.106", features = ["derive"] }
 
 [dev-dependencies]
 test_utils = { path = "../test_utils" }
+expect = { path = "../expect" }
 walkdir = "2.3.1"
+rayon = "1"
diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index 2ef173a03..abc7a646c 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -189,6 +189,21 @@ impl ast::RecordFieldList {
     }
 }
 
+impl ast::TypeAliasDef {
+    #[must_use]
+    pub fn remove_bounds(&self) -> ast::TypeAliasDef {
+        let colon = match self.colon_token() {
+            Some(it) => it,
+            None => return self.clone(),
+        };
+        let end = match self.type_bound_list() {
+            Some(it) => it.syntax().clone().into(),
+            None => colon.clone().into(),
+        };
+        self.replace_children(colon.into()..=end, iter::empty())
+    }
+}
+
 impl ast::TypeParam {
     #[must_use]
     pub fn remove_bounds(&self) -> ast::TypeParam {
@@ -299,12 +314,8 @@ impl ast::UseTree {
             Some(it) => it,
             None => return self.clone(),
         };
-        let use_tree = make::use_tree(
-            suffix.clone(),
-            self.use_tree_list(),
-            self.alias(),
-            self.star_token().is_some(),
-        );
+        let use_tree =
+            make::use_tree(suffix, self.use_tree_list(), self.alias(), self.star_token().is_some());
         let nested = make::use_tree_list(iter::once(use_tree));
         return make::use_tree(prefix.clone(), Some(nested), None, false);
 
diff --git a/crates/ra_syntax/src/ast/tokens.rs b/crates/ra_syntax/src/ast/tokens.rs
index 2e72d4927..045f69133 100644
--- a/crates/ra_syntax/src/ast/tokens.rs
+++ b/crates/ra_syntax/src/ast/tokens.rs
@@ -1,6 +1,9 @@
 //! There are many AstNodes, but only a few tokens, so we hand-write them here.
 
-use std::convert::{TryFrom, TryInto};
+use std::{
+    borrow::Cow,
+    convert::{TryFrom, TryInto},
+};
 
 use crate::{
     ast::{AstToken, Comment, RawString, String, Whitespace},
@@ -138,11 +141,11 @@ impl HasQuotes for String {}
 impl HasQuotes for RawString {}
 
 pub trait HasStringValue: HasQuotes {
-    fn value(&self) -> Option<std::string::String>;
+    fn value(&self) -> Option<Cow<'_, str>>;
 }
 
 impl HasStringValue for String {
-    fn value(&self) -> Option<std::string::String> {
+    fn value(&self) -> Option<Cow<'_, str>> {
         let text = self.text().as_str();
         let text = &text[self.text_range_between_quotes()? - self.syntax().text_range().start()];
 
@@ -156,15 +159,17 @@ impl HasStringValue for String {
         if has_error {
             return None;
         }
-        Some(buf)
+        // FIXME: don't actually allocate for borrowed case
+        let res = if buf == text { Cow::Borrowed(text) } else { Cow::Owned(buf) };
+        Some(res)
     }
 }
 
 impl HasStringValue for RawString {
-    fn value(&self) -> Option<std::string::String> {
+    fn value(&self) -> Option<Cow<'_, str>> {
         let text = self.text().as_str();
         let text = &text[self.text_range_between_quotes()? - self.syntax().text_range().start()];
-        Some(text.to_string())
+        Some(Cow::Borrowed(text))
     }
 }
 
diff --git a/crates/ra_syntax/src/parsing/text_tree_sink.rs b/crates/ra_syntax/src/parsing/text_tree_sink.rs
index 22aed1db1..c6b30a02a 100644
--- a/crates/ra_syntax/src/parsing/text_tree_sink.rs
+++ b/crates/ra_syntax/src/parsing/text_tree_sink.rs
@@ -160,7 +160,10 @@ fn n_attached_trivias<'a>(
                             if let Some((peek_kind, peek_text)) =
                                 trivias.peek().map(|(_, pair)| pair)
                             {
-                                if *peek_kind == COMMENT && peek_text.starts_with("///") {
+                                if *peek_kind == COMMENT
+                                    && peek_text.starts_with("///")
+                                    && !peek_text.starts_with("////")
+                                {
                                     continue;
                                 }
                             }
diff --git a/crates/ra_syntax/src/tests.rs b/crates/ra_syntax/src/tests.rs
index 7b4232497..8447dcad7 100644
--- a/crates/ra_syntax/src/tests.rs
+++ b/crates/ra_syntax/src/tests.rs
@@ -1,11 +1,12 @@
 use std::{
-    env,
     fmt::Write,
     fs,
-    path::{Component, Path, PathBuf},
+    path::{Path, PathBuf},
 };
 
-use test_utils::{assert_eq_text, project_dir};
+use expect::expect_file;
+use rayon::prelude::*;
+use test_utils::project_dir;
 
 use crate::{fuzz, tokenize, SourceFile, SyntaxError, TextRange, TextSize, Token};
 
@@ -121,33 +122,43 @@ fn reparse_fuzz_tests() {
 /// FIXME: Use this as a benchmark
 #[test]
 fn self_hosting_parsing() {
-    use std::ffi::OsStr;
     let dir = project_dir().join("crates");
-    let mut count = 0;
-    for entry in walkdir::WalkDir::new(dir)
+    let files = walkdir::WalkDir::new(dir)
         .into_iter()
         .filter_entry(|entry| {
-            !entry.path().components().any(|component| {
-                // Get all files which are not in the crates/ra_syntax/test_data folder
-                component == Component::Normal(OsStr::new("test_data"))
-            })
+            // Get all files which are not in the crates/ra_syntax/test_data folder
+            !entry.path().components().any(|component| component.as_os_str() == "test_data")
         })
         .map(|e| e.unwrap())
         .filter(|entry| {
             // Get all `.rs ` files
-            !entry.path().is_dir() && (entry.path().extension() == Some(OsStr::new("rs")))
+            !entry.path().is_dir() && (entry.path().extension().unwrap_or_default() == "rs")
         })
-    {
-        count += 1;
-        let text = read_text(entry.path());
-        if let Err(errors) = SourceFile::parse(&text).ok() {
-            panic!("Parsing errors:\n{:?}\n{}\n", errors, entry.path().display());
-        }
-    }
+        .map(|entry| entry.into_path())
+        .collect::<Vec<_>>();
     assert!(
-        count > 30,
+        files.len() > 100,
         "self_hosting_parsing found too few files - is it running in the right directory?"
-    )
+    );
+
+    let errors = files
+        .into_par_iter()
+        .filter_map(|file| {
+            let text = read_text(&file);
+            match SourceFile::parse(&text).ok() {
+                Ok(_) => None,
+                Err(err) => Some((file, err)),
+            }
+        })
+        .collect::<Vec<_>>();
+
+    if !errors.is_empty() {
+        let errors = errors
+            .into_iter()
+            .map(|(path, err)| format!("{}: {:?}\n", path.display(), err))
+            .collect::<String>();
+        panic!("Parsing errors:\n{}\n", errors);
+    }
 }
 
 fn test_data_dir() -> PathBuf {
@@ -218,15 +229,7 @@ where
     for (path, input_code) in collect_rust_files(test_data_dir, paths) {
         let actual = f(&input_code, &path);
         let path = path.with_extension(outfile_extension);
-        if !path.exists() {
-            println!("\nfile: {}", path.display());
-            println!("No .txt file with expected result, creating...\n");
-            println!("{}\n{}", input_code, actual);
-            fs::write(&path, &actual).unwrap();
-            panic!("No expected result");
-        }
-        let expected = read_text(&path);
-        assert_equal_text(&expected, &actual, &path);
+        expect_file![path].assert_eq(&actual)
     }
 }
 
@@ -259,29 +262,6 @@ fn rust_files_in_dir(dir: &Path) -> Vec<PathBuf> {
     acc
 }
 
-/// Asserts that `expected` and `actual` strings are equal. If they differ only
-/// in trailing or leading whitespace the test won't fail and
-/// the contents of `actual` will be written to the file located at `path`.
-fn assert_equal_text(expected: &str, actual: &str, path: &Path) {
-    if expected == actual {
-        return;
-    }
-    let dir = project_dir();
-    let pretty_path = path.strip_prefix(&dir).unwrap_or_else(|_| path);
-    if expected.trim() == actual.trim() {
-        println!("whitespace difference, rewriting");
-        println!("file: {}\n", pretty_path.display());
-        fs::write(path, actual).unwrap();
-        return;
-    }
-    if env::var("UPDATE_EXPECT").is_ok() {
-        println!("rewriting {}", pretty_path.display());
-        fs::write(path, actual).unwrap();
-        return;
-    }
-    assert_eq_text!(expected, actual, "file: {}", pretty_path.display());
-}
-
 /// Read file and normalize newlines.
 ///
 /// `rustc` seems to always normalize `\r\n` newlines to `\n`: