Allow filtering of OTP apps in indexing

Summary:
Many applications are included in the Erlang/OTP release, but they are not used by a project. Processing them leads to unnecessary work and memory consumption. This diff adds a new `otp` configuration section to the `.elp.toml` file, allowing users to customize a list of OTP applications to exclude from the analysis.

* Add new `OTP` section to ELP Config
* Pass reference to the whole ELP configuration to the project loading function
* Forward OTP config section to OTP discovery function
* Perform filtering
* Add documentation on how to use the new feature

Reviewed By: TheGeorge

Differential Revision: D83974071

fbshipit-source-id: eae11cd06eca9380d00ca5f7a3a70bb659d6ab71

Author: robertoaloi

crates/base_db/src/fixture.rs

@@ -295,7 +295,7 @@ impl ChangeFixture {
                 ProjectManifest::discover(&AbsPathBuf::assert(json_config_file.into())).unwrap();
             let loaded_project = Project::load(
                 &manifest,
-                elp_config.eqwalizer,
+                &elp_config,
                 &BuckQueryConfig::BuildGeneratedCode,
                 &|_| {},
             )

crates/elp/src/bin/build_info_cli.rs

@@ -16,7 +16,6 @@ use anyhow::Result;
 use elp_ide::elp_ide_db::elp_base_db::AbsPath;
 use elp_ide::elp_ide_db::elp_base_db::AbsPathBuf;
 use elp_project_model::ElpConfig;
-use elp_project_model::EqwalizerConfig;
 use elp_project_model::IncludeParentDirs;
 use elp_project_model::Project;
 use elp_project_model::ProjectBuildData;
@@ -31,8 +30,8 @@ use crate::args::ProjectInfo;
 pub(crate) fn save_build_info(args: BuildInfo, query_config: &BuckQueryConfig) -> Result<()> {
     let root = fs::canonicalize(&args.project)?;
     let root = AbsPathBuf::assert_utf8(root);
-    let (_elp_config, manifest) = ProjectManifest::discover(&root)?;
-    let project = Project::load(&manifest, EqwalizerConfig::default(), query_config, &|_| {})?;
+    let (elp_config, manifest) = ProjectManifest::discover(&root)?;
+    let project = Project::load(&manifest, &elp_config, query_config, &|_| {})?;
     let mut writer = File::create(&args.to)?;
     let json_str = serde_json::to_string_pretty::<JsonConfig>(&project.as_json(root))?;
     writer.write_all(json_str.as_bytes())?;
@@ -84,7 +83,7 @@ fn load_project(
     query_config: &BuckQueryConfig,
 ) -> Result<(ProjectManifest, Project)> {
     let (elp_config, manifest) = ProjectManifest::discover(root)?;
-    let project = Project::load(&manifest, elp_config.eqwalizer, query_config, &|_| {})?;
+    let project = Project::load(&manifest, &elp_config, query_config, &|_| {})?;
     Ok((manifest, project))
 }
 
@@ -94,6 +93,6 @@ fn load_fallback(
 ) -> Result<(ProjectManifest, Project)> {
     let manifest = ProjectManifest::discover_no_manifest(root, IncludeParentDirs::Yes);
     let elp_config = ElpConfig::default();
-    let project = Project::load(&manifest, elp_config.eqwalizer, query_config, &|_| {})?;
+    let project = Project::load(&manifest, &elp_config, query_config, &|_| {})?;
     Ok((manifest, project))
 }

crates/elp/src/build/load.rs

@@ -80,12 +80,7 @@ pub fn load_project_at(
 
     log::info!("Discovered project: {manifest:?}");
     let pb = cli.spinner("Loading build info");
-    let project = Project::load(
-        &manifest,
-        elp_config.eqwalizer.clone(),
-        query_config,
-        &|_progress| {},
-    )?;
+    let project = Project::load(&manifest, &elp_config, query_config, &|_progress| {})?;
     pb.finish();
 
     load_project(cli, project, include_otp, eqwalizer_mode)

crates/elp/src/server.rs

@@ -1724,12 +1724,9 @@ impl Server {
         };
 
         spinner.report("Loading project".to_string());
-        let mut project = Project::load(
-            &manifest,
-            elp_config.eqwalizer.clone(),
-            query_config,
-            &|message| spinner.report(message.to_string()),
-        );
+        let mut project = Project::load(&manifest, &elp_config, query_config, &|message| {
+            spinner.report(message.to_string())
+        });
         if let Err(err) = &project {
             log::error!("Failed to load project for manifest {manifest:?}, error: {err:?}");
             match err.downcast_ref::<BuckQueryError>() {
@@ -1745,10 +1742,9 @@ impl Server {
                 }
             }
             if !fallback_used {
-                project =
-                    Project::load(&fallback, elp_config.eqwalizer, query_config, &|message| {
-                        spinner.report(message.to_string())
-                    });
+                project = Project::load(&fallback, &elp_config, query_config, &|message| {
+                    spinner.report(message.to_string())
+                });
                 if let Err(err) = &project {
                     log::error!(
                         "Failed to load project for fallback manifest {manifest:?}, error: {err:?}"

crates/elp/tests/slow-tests/buck_tests.rs

@@ -82,13 +82,8 @@ mod tests {
         let (elp_config, buck_config) =
             ProjectManifest::discover(&to_abs_path_buf(&path).unwrap()).unwrap();
 
-        let project = Project::load(
-            &buck_config,
-            elp_config.eqwalizer,
-            &BUCK_QUERY_CONFIG,
-            &|_| {},
-        )
-        .unwrap();
+        let project =
+            Project::load(&buck_config, &elp_config, &BUCK_QUERY_CONFIG, &|_| {}).unwrap();
 
         let project_data: Vec<ProjectAppData> = project
             .non_otp_apps()

crates/project_model/src/buck.rs

@@ -326,6 +326,7 @@ impl IncludeMapping {
 impl BuckProject {
     pub fn load_from_config(
         buck_conf: &BuckConfig,
+        elp_config: &ElpConfig,
         query_config: &BuckQueryConfig,
         report_progress: &impl Fn(&str),
     ) -> Result<
@@ -349,7 +350,7 @@ impl BuckProject {
         };
         let otp_root = Otp::find_otp()?;
         // TODO: we now get these twice. Perhaps they should be cached?
-        let (_otp, otp_project_apps) = Otp::discover(otp_root.clone());
+        let (_otp, otp_project_apps) = Otp::discover(otp_root.clone(), &elp_config.otp);
         include_mapping.add_otp(&otp_project_apps);
         Ok((
             project,

crates/project_model/src/lib.rs

@@ -385,6 +385,8 @@ pub struct ElpConfig {
     pub eqwalizer: EqwalizerConfig,
     #[serde(default)]
     pub rebar: ElpRebarConfig,
+    #[serde(default)]
+    pub otp: OtpConfig,
 }
 
 #[derive(
@@ -501,6 +503,22 @@ impl Default for ElpRebarConfig {
     }
 }
 
+#[derive(
+    Debug,
+    Default,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    Ord,
+    PartialOrd,
+    Deserialize,
+    Serialize
+)]
+pub struct OtpConfig {
+    pub exclude_apps: Vec<String>,
+}
+
 impl ElpConfig {
     pub fn new(
         config_path: AbsPathBuf,
@@ -515,6 +533,7 @@ impl ElpConfig {
             build_info,
             eqwalizer,
             rebar,
+            otp: OtpConfig::default(),
         }
     }
     pub fn try_parse(path: &AbsPath) -> Result<ElpConfig> {
@@ -998,7 +1017,7 @@ impl Project {
 
     pub fn load(
         manifest: &ProjectManifest,
-        eqwalizer_config: EqwalizerConfig,
+        elp_config: &ElpConfig,
         query_config: &BuckQueryConfig,
         report_progress: &impl Fn(&str),
     ) -> Result<Project> {
@@ -1032,7 +1051,7 @@ impl Project {
             ProjectManifest::TomlBuck(buck) => {
                 // We only select this manifest if buck is actually enabled
                 let (project, apps, otp_root, include_mapping) =
-                    BuckProject::load_from_config(buck, query_config, report_progress)?;
+                    BuckProject::load_from_config(buck, elp_config, query_config, report_progress)?;
                 (
                     ProjectBuildData::Buck(project),
                     apps,
@@ -1061,14 +1080,14 @@ impl Project {
             }
         };
 
-        let (otp, otp_project_apps) = Otp::discover(otp_root);
+        let (otp, otp_project_apps) = Otp::discover(otp_root, &elp_config.otp);
         project_apps.extend(otp_project_apps);
         report_progress("Project info loaded");
         Ok(Project {
             otp,
             project_build_data: project_build_info,
             project_apps,
-            eqwalizer_config,
+            eqwalizer_config: elp_config.eqwalizer.clone(),
             include_mapping,
         })
     }
@@ -1172,6 +1191,9 @@ mod tests {
                         rebar: ElpRebarConfig {
                             profile: "test",
                         },
+                        otp: OtpConfig {
+                            exclude_apps: [],
+                        },
                     },
                     Rebar(
                         RebarConfig {
@@ -1237,6 +1259,9 @@ mod tests {
                         rebar: ElpRebarConfig {
                             profile: "test",
                         },
+                        otp: OtpConfig {
+                            exclude_apps: [],
+                        },
                     },
                     Json(
                         JsonConfig {
@@ -1347,6 +1372,9 @@ mod tests {
                         rebar: ElpRebarConfig {
                             profile: "test",
                         },
+                        otp: OtpConfig {
+                            exclude_apps: [],
+                        },
                     },
                     JsonConfig {
                         apps: [
@@ -1502,6 +1530,9 @@ mod tests {
                         rebar: ElpRebarConfig {
                             profile: "test",
                         },
+                        otp: OtpConfig {
+                            exclude_apps: [],
+                        },
                     },
                     NoManifest(
                         NoManifestConfig {
@@ -1571,6 +1602,9 @@ mod tests {
                             rebar: ElpRebarConfig {
                                 profile: "test",
                             },
+                            otp: OtpConfig {
+                                exclude_apps: [],
+                            },
                         },
                         NoManifest(
                             NoManifestConfig {
@@ -1764,6 +1798,9 @@ mod tests {
                     rebar: ElpRebarConfig {
                         profile: "other",
                     },
+                    otp: OtpConfig {
+                        exclude_apps: [],
+                    },
                 }
             "#]]
             .assert_eq(&debug_normalise_temp_dir(dir, &elp_config));
@@ -1807,6 +1844,7 @@ mod tests {
             rebar: ElpRebarConfig {
                 profile: "my_profile".to_string(),
             },
+            otp: OtpConfig::default(),
         })
         .unwrap();
         expect![[r#"
@@ -1829,6 +1867,9 @@ mod tests {
 
             [rebar]
             profile = "my_profile"
+
+            [otp]
+            exclude_apps = []
         "#]]
         .assert_eq(&result);
     }
@@ -1902,6 +1943,9 @@ mod tests {
                 rebar: ElpRebarConfig {
                     profile: "my_profile",
                 },
+                otp: OtpConfig {
+                    exclude_apps: [],
+                },
             }
         "#]]
         .assert_debug_eq(&lints);
@@ -2017,4 +2061,112 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_toml_otp_exclude_apps() {
+        let spec = r#"
+        //- /.elp.toml
+        [otp]
+        exclude_apps = ["megaco", "eunit"]
+        //- /app_a/src/app.erl
+        -module(app).
+        "#;
+        let dir = FixtureWithProjectMeta::gen_project(spec);
+        if let Ok((elp_config, ProjectManifest::NoManifest(_))) = ProjectManifest::discover(
+            &to_abs_path_buf(&dir.path().join("app_a/src/app.erl")).unwrap(),
+        ) {
+            expect![[r#"
+                ElpConfig {
+                    config_path: Some(
+                        AbsPathBuf(
+                            "TMPDIR/.elp.toml",
+                        ),
+                    ),
+                    build_info: None,
+                    buck: None,
+                    eqwalizer: EqwalizerConfig {
+                        enable_all: true,
+                        max_tasks: 4,
+                        ignore_modules: [],
+                        ignore_modules_compiled_patterns: [],
+                    },
+                    rebar: ElpRebarConfig {
+                        profile: "test",
+                    },
+                    otp: OtpConfig {
+                        exclude_apps: [
+                            "megaco",
+                            "eunit",
+                        ],
+                    },
+                }
+            "#]]
+            .assert_eq(&debug_normalise_temp_dir(dir, &elp_config));
+        } else {
+            panic!()
+        }
+    }
+
+    #[test]
+    fn serde_serialize_elp_toml_with_otp() {
+        let result = toml::to_string::<ElpConfig>(&ElpConfig {
+            config_path: None,
+            build_info: None,
+            buck: None,
+            eqwalizer: EqwalizerConfig::default(),
+            rebar: ElpRebarConfig::default(),
+            otp: OtpConfig {
+                exclude_apps: vec!["megaco".to_string(), "eunit".to_string()],
+            },
+        })
+        .unwrap();
+        expect![[r#"
+            [eqwalizer]
+            enable_all = true
+            max_tasks = 4
+            ignore_modules = []
+
+            [rebar]
+            profile = "test"
+
+            [otp]
+            exclude_apps = ["megaco", "eunit"]
+        "#]]
+        .assert_eq(&result);
+    }
+
+    #[test]
+    fn serde_deserialize_elp_toml_with_otp() {
+        let config: ElpConfig = toml::from_str(
+            r#"
+            [otp]
+            exclude_apps = ["megaco", "eunit"]
+             "#,
+        )
+        .unwrap();
+
+        expect![[r#"
+            ElpConfig {
+                config_path: None,
+                build_info: None,
+                buck: None,
+                eqwalizer: EqwalizerConfig {
+                    enable_all: true,
+                    max_tasks: 4,
+                    ignore_modules: [],
+                    ignore_modules_compiled_patterns: [],
+                },
+                rebar: ElpRebarConfig {
+                    profile: "test",
+                },
+                otp: OtpConfig {
+                    exclude_apps: [
+                        "megaco",
+                        "eunit",
+                    ],
+                },
+            }
+        "#]]
+        .assert_debug_eq(&config);
+    }
 }