Add extra_sources to project config

Reviewed By: voideanvalue, tyao1

Differential Revision: D56659647

fbshipit-source-id: 1912afd03b6dda5b99e38604fbca2a5190389d30

Author: omarchehab98

compiler/crates/relay-compiler/src/config.rs

@@ -96,6 +96,10 @@ pub struct Config {
     pub root_dir: PathBuf,
     pub sources: FnvIndexMap<PathBuf, ProjectSet>,
     pub excludes: Vec<String>,
+    /// Some projects may need to include extra source directories without being
+    /// affected by exclusion globs from the `excludes` config (e.g. generated
+    /// directories).
+    pub generated_sources: FnvIndexMap<PathBuf, ProjectSet>,
     pub projects: FnvIndexMap<ProjectName, ProjectConfig>,
     pub header: Vec<String>,
     pub codegen_command: Option<String>,
@@ -422,6 +426,7 @@ impl Config {
             root_dir,
             sources: config_file.sources,
             excludes: config_file.excludes,
+            generated_sources: config_file.generated_sources,
             projects,
             header: config_file.header,
             codegen_command: config_file.codegen_command,
@@ -580,6 +585,7 @@ impl fmt::Debug for Config {
             root_dir,
             sources,
             excludes,
+            generated_sources,
             compile_everything,
             repersist_operations,
             projects,
@@ -604,6 +610,7 @@ impl fmt::Debug for Config {
             .field("root_dir", root_dir)
             .field("sources", sources)
             .field("excludes", excludes)
+            .field("generated_sources", generated_sources)
             .field("compile_everything", compile_everything)
             .field("repersist_operations", repersist_operations)
             .field("projects", projects)
@@ -663,13 +670,17 @@ struct MultiProjectConfigFile {
     /// A mapping from directory paths (relative to the root) to a source set.
     /// If a path is a subdirectory of another path, the more specific path
     /// wins.
-    sources: IndexMap<PathBuf, ProjectSet, fnv::FnvBuildHasher>,
+    sources: FnvIndexMap<PathBuf, ProjectSet>,
 
     /// Glob patterns that should not be part of the sources even if they are
     /// in the source set directories.
     #[serde(default = "get_default_excludes")]
     excludes: Vec<String>,
 
+    /// Similar to sources but not affected by excludes.
+    #[serde(default)]
+    generated_sources: FnvIndexMap<PathBuf, ProjectSet>,
+
     /// Configuration of projects to compile.
     projects: FnvIndexMap<ProjectName, ConfigFileProject>,
 

compiler/crates/relay-compiler/src/file_source/file_categorizer.rs

@@ -149,10 +149,13 @@ impl FileCategorizer {
         for (path, project_set) in &config.sources {
             source_mapping.push((path.clone(), project_set.clone()));
         }
+        for (path, project_set) in &config.generated_sources {
+            source_mapping.push((path.clone(), project_set.clone()));
+        }
 
         let default_generated_dir = OsStr::new("__generated__");
         let mut generated_sources = vec![];
-        for (path, _project_set) in &config.sources {
+        for (path, _project_set) in &config.generated_sources {
             if in_relative_generated_dir(default_generated_dir, path) {
                 generated_sources.push(path.clone());
             }
@@ -400,7 +403,9 @@ mod tests {
                         "src/vendor": "public",
                         "src/custom": "with_custom_generated_dir",
                         "src/typescript": "typescript",
-                        "src/custom_overlapping": ["with_custom_generated_dir", "overlapping_generated_dir"],
+                        "src/custom_overlapping": ["with_custom_generated_dir", "overlapping_generated_dir"]
+                    },
+                    "generatedSources": {
                         "src/resolver_codegen/__generated__": "public"
                     },
                     "projects": {

compiler/crates/relay-compiler/src/file_source/watchman_query_builder.rs

@@ -7,48 +7,19 @@
 
 use std::path::PathBuf;
 
+use fnv::FnvBuildHasher;
+use indexmap::IndexMap;
 use relay_typegen::TypegenLanguage;
 use watchman_client::prelude::*;
 
+use crate::compiler_state::ProjectSet;
 use crate::config::Config;
 use crate::config::SchemaLocation;
 
+type FnvIndexMap<K, V> = IndexMap<K, V, FnvBuildHasher>;
+
 pub fn get_watchman_expr(config: &Config) -> Expr {
-    let mut sources_conditions = vec![expr_any(
-        config
-            .sources
-            .iter()
-            .flat_map(|(path, project_set)| {
-                project_set
-                    .iter()
-                    .map(|name| (path, &config.projects[name]))
-                    .collect::<Vec<_>>()
-            })
-            .map(|(path, project)| {
-                Expr::All(vec![
-                    // Ending in *.js(x) or *.ts(x) depending on the project language.
-                    Expr::Suffix(match &project.typegen_config.language {
-                        TypegenLanguage::Flow | TypegenLanguage::JavaScript => {
-                            vec![PathBuf::from("js"), PathBuf::from("jsx")]
-                        }
-                        TypegenLanguage::TypeScript => {
-                            vec![
-                                PathBuf::from("js"),
-                                PathBuf::from("jsx"),
-                                PathBuf::from("ts"),
-                                PathBuf::from("tsx"),
-                            ]
-                        }
-                    }),
-                    // In the related source root.
-                    Expr::DirName(DirNameTerm {
-                        path: path.clone(),
-                        depth: None,
-                    }),
-                ])
-            })
-            .collect(),
-    )];
+    let mut sources_conditions = vec![expr_any(get_sources_dir_exprs(config, &config.sources))];
     // not excluded by any glob
     if !config.excludes.is_empty() {
         sources_conditions.push(Expr::Not(Box::new(expr_any(
@@ -69,6 +40,11 @@ pub fn get_watchman_expr(config: &Config) -> Expr {
 
     let mut expressions = vec![sources_expr];
 
+    let generated_sources_dir_exprs = get_sources_dir_exprs(config, &config.generated_sources);
+    if !generated_sources_dir_exprs.is_empty() {
+        expressions.push(expr_any(generated_sources_dir_exprs));
+    }
+
     let output_dir_paths = get_output_dir_paths(config);
     if !output_dir_paths.is_empty() {
         let output_dir_expr = expr_files_in_dirs(output_dir_paths);
@@ -103,17 +79,62 @@ pub fn get_watchman_expr(config: &Config) -> Expr {
     ])
 }
 
+fn get_sources_dir_exprs(
+    config: &Config,
+    paths_to_project: &FnvIndexMap<PathBuf, ProjectSet>,
+) -> Vec<Expr> {
+    paths_to_project
+        .iter()
+        .flat_map(|(path, project_set)| {
+            project_set
+                .iter()
+                .map(|name| (path, &config.projects[name]))
+                .collect::<Vec<_>>()
+        })
+        .map(|(path, project)| {
+            Expr::All(vec![
+                // In the related source root.
+                Expr::DirName(DirNameTerm {
+                    path: path.clone(),
+                    depth: None,
+                }),
+                // Match file extensions
+                get_project_file_ext_expr(project.typegen_config.language),
+            ])
+        })
+        .collect()
+}
+
+fn get_project_file_ext_expr(typegen_language: TypegenLanguage) -> Expr {
+    // Ending in *.js(x) or *.ts(x) depending on the project language.
+    Expr::Suffix(match &typegen_language {
+        TypegenLanguage::Flow | TypegenLanguage::JavaScript => {
+            vec![PathBuf::from("js"), PathBuf::from("jsx")]
+        }
+        TypegenLanguage::TypeScript => {
+            vec![
+                PathBuf::from("js"),
+                PathBuf::from("jsx"),
+                PathBuf::from("ts"),
+                PathBuf::from("tsx"),
+            ]
+        }
+    })
+}
+
 /// Compute all root paths that we need to query Watchman with. All files
 /// relevant to the compiler should be in these directories.
 pub fn get_all_roots(config: &Config) -> Vec<PathBuf> {
     let source_roots = get_source_roots(config);
+    let extra_sources_roots = get_generated_sources_roots(config);
     let output_roots = get_output_dir_paths(config);
     let extension_roots = get_extension_roots(config);
     let schema_file_roots = get_schema_file_roots(config);
     let schema_dir_roots = get_schema_dir_paths(config);
     unify_roots(
         source_roots
             .into_iter()
+            .chain(extra_sources_roots)
             .chain(output_roots)
             .chain(extension_roots)
             .chain(schema_file_roots)
@@ -127,6 +148,11 @@ fn get_source_roots(config: &Config) -> Vec<PathBuf> {
     config.sources.keys().cloned().collect()
 }
 
+/// Returns all root directories of JS source files for the config.
+fn get_generated_sources_roots(config: &Config) -> Vec<PathBuf> {
+    config.generated_sources.keys().cloned().collect()
+}
+
 /// Returns all root directories of GraphQL schema extension files for the
 /// config.
 fn get_extension_roots(config: &Config) -> Vec<PathBuf> {