WIP: Use configurable blacklist

Author: Xanewok

Cargo.lock

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

Cargo.toml

@@ -42,7 +42,8 @@ fn main() {
         std::process::exit(1);
     }
     let loader = Loader::new(PathBuf::from(env::args().nth(1).unwrap()));
-    let crates = rls_analysis::read_analysis_from_files(&loader, Default::default(), &[]);
+    let crates =
+        rls_analysis::read_analysis_from_files(&loader, Default::default(), &[] as &[&str]);
 
     for krate in &crates {
         println!("Crate {:?} data version {:?}", krate.id, krate.analysis.version);

rls-analysis/examples/print-crate-id.rs

@@ -25,6 +25,7 @@ pub use raw::{name_space_for_def_kind, read_analysis_from_files, Crate, CrateId,
 pub use symbol_query::SymbolQuery;
 
 use std::collections::HashMap;
+use std::fmt::Debug;
 use std::path::{Path, PathBuf};
 use std::sync::Mutex;
 use std::time::{Instant, SystemTime};
@@ -85,8 +86,6 @@ impl Id {
 /// Used to indicate a missing index in the Id.
 pub const NULL: Id = Id(u64::MAX);
 
-type Blacklist<'a> = &'a [&'static str];
-
 macro_rules! clone_field {
     ($field: ident) => {
         |x| x.$field.clone()
@@ -126,7 +125,7 @@ impl<L: AnalysisLoader> AnalysisHost<L> {
         analysis: Vec<data::Analysis>,
         path_prefix: &Path,
         base_dir: &Path,
-        blacklist: Blacklist<'_>,
+        blacklist: &[impl AsRef<str> + Debug],
     ) -> AResult<()> {
         self.reload_with_blacklist(path_prefix, base_dir, blacklist)?;
 
@@ -143,14 +142,14 @@ impl<L: AnalysisLoader> AnalysisHost<L> {
     }
 
     pub fn reload(&self, path_prefix: &Path, base_dir: &Path) -> AResult<()> {
-        self.reload_with_blacklist(path_prefix, base_dir, &[])
+        self.reload_with_blacklist(path_prefix, base_dir, &[] as &[&str])
     }
 
     pub fn reload_with_blacklist(
         &self,
         path_prefix: &Path,
         base_dir: &Path,
-        blacklist: Blacklist<'_>,
+        blacklist: &[impl AsRef<str> + Debug],
     ) -> AResult<()> {
         trace!("reload_with_blacklist {:?} {:?} {:?}", path_prefix, base_dir, blacklist);
         let empty = self.analysis.lock()?.is_none();
@@ -173,14 +172,14 @@ impl<L: AnalysisLoader> AnalysisHost<L> {
 
     /// Reloads the entire project's analysis data.
     pub fn hard_reload(&self, path_prefix: &Path, base_dir: &Path) -> AResult<()> {
-        self.hard_reload_with_blacklist(path_prefix, base_dir, &[])
+        self.hard_reload_with_blacklist(path_prefix, base_dir, &[] as &[&str])
     }
 
     pub fn hard_reload_with_blacklist(
         &self,
         path_prefix: &Path,
         base_dir: &Path,
-        blacklist: Blacklist<'_>,
+        blacklist: &[impl AsRef<str> + Debug],
     ) -> AResult<()> {
         trace!("hard_reload {:?} {:?}", path_prefix, base_dir);
         // We're going to create a dummy AnalysisHost that we will fill with data,
@@ -542,7 +541,7 @@ impl<L: AnalysisLoader> AnalysisHost<L> {
 
 impl ::std::fmt::Display for Id {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        self.0.fmt(f)
+        ::std::fmt::Display::fmt(&self.0, f)
     }
 }
 

rls-analysis/src/lib.rs

@@ -6,13 +6,14 @@ pub use data::{
 };
 
 use std::collections::HashMap;
+use std::fmt::Debug;
 use std::fs::File;
 use std::io::{self, Read};
 use std::path::{Path, PathBuf};
 use std::time::{Instant, SystemTime};
 
 use crate::listings::{DirectoryListing, ListingKind};
-use crate::{AnalysisLoader, Blacklist};
+use crate::AnalysisLoader;
 
 #[derive(Debug)]
 pub struct Crate {
@@ -45,7 +46,7 @@ impl Crate {
 pub fn read_analysis_from_files<L: AnalysisLoader>(
     loader: &L,
     crate_timestamps: HashMap<PathBuf, SystemTime>,
-    crate_blacklist: Blacklist<'_>,
+    crate_blacklist: &[impl AsRef<str> + Debug],
 ) -> Vec<Crate> {
     let mut result = vec![];
 
@@ -92,8 +93,8 @@ pub fn read_analysis_from_files<L: AnalysisLoader>(
     result
 }
 
-fn ignore_data(file_name: &str, crate_blacklist: Blacklist<'_>) -> bool {
-    crate_blacklist.iter().any(|name| file_name.starts_with(&format!("lib{}-", name)))
+fn ignore_data(file_name: &str, crate_blacklist: &[impl AsRef<str>]) -> bool {
+    crate_blacklist.iter().any(|name| file_name.starts_with(&format!("lib{}-", name.as_ref())))
 }
 
 fn read_file_contents(path: &Path) -> io::Result<String> {

rls-analysis/src/raw.rs

@@ -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()]);
+}