rls: Introduce crate_blacklist config allowing for custom blacklists

This in turns removes the old `use_crate_blacklist` setting. To not use
the blacklist, one can specify `[]` as the config value.

Author: Xanewok

Cargo.lock

@@ -21,7 +21,7 @@ test = false
 path = "rls/src/main.rs"
 
 [dependencies]
-rls-analysis = "0.17.0"
+rls-analysis = "0.18.0"
 rls-blacklist = "0.1.3"
 rls-data = "0.19"
 # FIXME: Release rls-rustc 0.6.0 to crates.io

Cargo.toml

@@ -115,8 +115,10 @@ Currently we accept the following options:
 * `all_targets` (`bool`, defaults to `true`) checks the project as if you were
   running `cargo check --all-targets`. I.e., check all targets and integration
   tests too
-* `use_crate_blacklist` (`bool`, defaults to `true`) if disabled, also indexes
-  data from the [blacklisted](https://github.com/nrc/rls-blacklist/blob/master/src/lib.rs) crates
+* `crate_blacklist` (`[String]`, defaults to [this list](https://github.com/rust-dev-tools/rls-blacklist/blob/master/src/lib.rs))
+  allows to specify which crates should be skipped by the RLS.
+  By default skips libraries that are of considerable size but which the user
+  often may not be directly interested in, thus reducing the build latency.
 * `build_on_save` (`bool`, defaults to `false`) toggles whether the RLS should
   perform continuous analysis or only after a file is saved
 * `features` (`[String]`, defaults to empty) list of Cargo features to enable

README.md

@@ -335,7 +335,7 @@ impl InitActionContext {
                 related_information_support: self.client_capabilities.related_information_support,
                 shown_cargo_error: self.shown_cargo_error.clone(),
                 active_build_count: self.active_build_count.clone(),
-                use_black_list: config.use_crate_blacklist,
+                crate_blacklist: config.crate_blacklist.as_ref().clone(),
                 notifier: Box::new(BuildDiagnosticsNotifier::new(out.clone())),
                 blocked_threads: vec![],
                 _token: token,

rls/src/actions/mod.rs

@@ -16,6 +16,7 @@ use crate::actions::diagnostics::{parse_diagnostics, Diagnostic, ParsedDiagnosti
 use crate::actions::progress::DiagnosticsNotifier;
 use crate::build::{BuildResult, Crate};
 use crate::concurrency::JobToken;
+use crate::config::CrateBlacklist;
 use crate::lsp_data::{PublishDiagnosticsParams, Range};
 
 use failure;
@@ -35,7 +36,7 @@ pub struct PostBuildHandler {
     pub file_to_crates: Arc<Mutex<HashMap<PathBuf, HashSet<Crate>>>>,
     pub project_path: PathBuf,
     pub show_warnings: bool,
-    pub use_black_list: bool,
+    pub crate_blacklist: CrateBlacklist,
     pub related_information_support: bool,
     pub shown_cargo_error: Arc<AtomicBool>,
     pub active_build_count: Arc<AtomicUsize>,
@@ -172,28 +173,15 @@ impl PostBuildHandler {
     }
 
     fn reload_analysis_from_disk(&self, cwd: &Path) {
-        if self.use_black_list {
-            self.analysis
-                .reload_with_blacklist(&self.project_path, cwd, &rls_blacklist::CRATE_BLACKLIST)
-                .unwrap();
-        } else {
-            self.analysis.reload(&self.project_path, cwd).unwrap();
-        }
+        self.analysis
+            .reload_with_blacklist(&self.project_path, cwd, &self.crate_blacklist.0[..])
+            .unwrap();
     }
 
     fn reload_analysis_from_memory(&self, cwd: &Path, analysis: Vec<Analysis>) {
-        if self.use_black_list {
-            self.analysis
-                .reload_from_analysis(
-                    analysis,
-                    &self.project_path,
-                    cwd,
-                    &rls_blacklist::CRATE_BLACKLIST,
-                )
-                .unwrap();
-        } else {
-            self.analysis.reload_from_analysis(analysis, &self.project_path, cwd, &[]).unwrap();
-        }
+        self.analysis
+            .reload_from_analysis(analysis, &self.project_path, cwd, &self.crate_blacklist.0[..])
+            .unwrap();
     }
 
     fn finalize(mut self) {

rls/src/actions/post_build.rs

@@ -498,19 +498,23 @@ impl Executor for RlsExecutor {
                 cmd.get_envs(),
             );
 
-            if rls_blacklist::CRATE_BLACKLIST.contains(&&*crate_name) {
+            let (crate_blacklist, full_docs) = {
+                let config = self.config.lock().unwrap();
+                (config.crate_blacklist.clone(), *config.full_docs.clone().as_ref())
+            };
+            if crate_blacklist.as_ref().0.contains(&crate_name) {
                 // By running the original command (rather than using our shim), we
                 // avoid producing save-analysis data.
                 trace!("crate is blacklisted");
                 return cargo_cmd.exec();
             }
             // Only include public symbols in externally compiled deps data
-            let mut save_config = rls_data::config::Config::default();
-            save_config.pub_only = true;
-            save_config.reachable_only = true;
-            save_config.full_docs =
-                self.config.lock().map(|config| *config.full_docs.as_ref()).unwrap();
-            let save_config = serde_json::to_string(&save_config)?;
+            let save_config = serde_json::to_string(&rls_data::config::Config {
+                pub_only: true,
+                reachable_only: true,
+                full_docs,
+                ..Default::default()
+            })?;
             cmd.env("RUST_SAVE_ANALYSIS_CONFIG", &OsString::from(save_config));
 
             return cmd.exec();

rls/src/build/cargo.rs

@@ -8,6 +8,7 @@ use std::io::sink;
 use std::marker::PhantomData;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
+use std::sync::Arc;
 
 use cargo::core::{Shell, Workspace};
 use cargo::util::{homedir, important_paths, Config as CargoConfig};
@@ -135,7 +136,9 @@ pub struct Config {
     /// `true` to build the project only when a file got saved and not on file change.
     /// Default: `false`.
     pub build_on_save: bool,
-    pub use_crate_blacklist: bool,
+    /// Blacklist of crates for RLS to skip. By default omits `winapi`, Unicode
+    /// table crates, `serde`, `libc`, `glium` and other.
+    pub crate_blacklist: Inferrable<CrateBlacklist>,
     /// The Cargo target directory. If set, overrides the default one.
     pub target_dir: Inferrable<Option<PathBuf>>,
     pub features: Vec<String>,
@@ -185,7 +188,7 @@ impl Default for Config {
             show_warnings: true,
             clear_env_rust_log: true,
             build_on_save: false,
-            use_crate_blacklist: true,
+            crate_blacklist: Inferrable::Inferred(CrateBlacklist::default()),
             target_dir: Inferrable::Inferred(None),
             features: vec![],
             all_features: false,
@@ -432,10 +435,65 @@ impl Default for FmtConfig {
     }
 }
 
+#[derive(Clone, Debug, PartialEq)]
+/// List of crates for which IDE analysis should not be generated
+pub struct CrateBlacklist(pub Arc<[String]>);
+
+impl<'de> Deserialize<'de> for CrateBlacklist {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let boxed = <Box<[String]> as serde::Deserialize>::deserialize(deserializer)?;
+        Ok(CrateBlacklist(boxed.into()))
+    }
+}
+
+impl Default for CrateBlacklist {
+    fn default() -> Self {
+        CrateBlacklist(
+            [
+                "cocoa",
+                "gleam",
+                "glium",
+                "idna",
+                "libc",
+                "openssl",
+                "rustc_serialize",
+                "serde",
+                "serde_json",
+                "typenum",
+                "unicode_normalization",
+                "unicode_segmentation",
+                "winapi",
+            ]
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .into(),
+        )
+    }
+}
+
 #[test]
 fn clippy_preference_from_str() {
     assert_eq!(ClippyPreference::from_str("Optin"), Ok(ClippyPreference::OptIn));
     assert_eq!(ClippyPreference::from_str("OFF"), Ok(ClippyPreference::Off));
     assert_eq!(ClippyPreference::from_str("opt-in"), Ok(ClippyPreference::OptIn));
     assert_eq!(ClippyPreference::from_str("on"), Ok(ClippyPreference::On));
 }
+
+#[test]
+fn blacklist_default() {
+    let value = serde_json::json!({});
+    let config = Config::try_deserialize(&value, &mut Default::default(), &mut vec![]).unwrap();
+    assert_eq!(config.crate_blacklist.as_ref(), &CrateBlacklist::default());
+    let value = serde_json::json!({"crate_blacklist": []});
+
+    let config = Config::try_deserialize(&value, &mut Default::default(), &mut vec![]).unwrap();
+    assert_eq!(&*config.crate_blacklist.as_ref().0, &[] as &[String]);
+
+    let value = serde_json::json!({"crate_blacklist": ["serde"]});
+    let config = Config::try_deserialize(&value, &mut Default::default(), &mut vec![]).unwrap();
+    assert_eq!(&*config.crate_blacklist.as_ref().0, &["serde".to_string()]);
+}