upstream changes

Author: jfrolich

rewatch/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rewatch"
-version = "1.1.3"
+version = "1.2.0"
 edition = "2021"
 
 [dependencies]

rewatch/Cargo.toml

@@ -12,7 +12,6 @@ use crate::build::compile::{mark_modules_with_deleted_deps_dirty, mark_modules_w
 use crate::helpers::emojis::*;
 use crate::helpers::{self, get_workspace_root};
 use crate::sourcedirs;
-use ahash::AHashSet;
 use anyhow::{anyhow, Result};
 use build_types::*;
 use console::style;
@@ -134,6 +133,7 @@ pub fn initialize_build(
     show_progress: bool,
     path: &str,
     bsc_path: Option<String>,
+    build_dev_deps: bool,
 ) -> Result<BuildState> {
     let project_root = helpers::get_abs_path(path);
     let workspace_root = helpers::get_workspace_root(&project_root);
@@ -150,7 +150,13 @@ pub fn initialize_build(
     }
 
     let timing_package_tree = Instant::now();
-    let packages = packages::make(filter, &project_root, &workspace_root, show_progress)?;
+    let packages = packages::make(
+        filter,
+        &project_root,
+        &workspace_root,
+        show_progress,
+        build_dev_deps,
+    )?;
     let timing_package_tree_elapsed = timing_package_tree.elapsed();
 
     if show_progress {
@@ -276,7 +282,7 @@ impl fmt::Display for IncrementalBuildError {
 pub fn incremental_build(
     build_state: &mut BuildState,
     default_timing: Option<Duration>,
-    initial_build: bool,
+    _initial_build: bool,
     show_progress: bool,
     only_incremental: bool,
     create_sourcedirs: bool,
@@ -350,17 +356,7 @@ pub fn incremental_build(
         );
     }
 
-    // track the compile dirty state, we reset it when the compile fails
-    let mut tracked_dirty_modules = AHashSet::new();
-    for (module_name, module) in build_state.modules.iter() {
-        if module.compile_dirty {
-            tracked_dirty_modules.insert(module_name.to_owned());
-        }
-    }
-    if initial_build {
-        // repair broken state
-        mark_modules_with_expired_deps_dirty(build_state);
-    }
+    mark_modules_with_expired_deps_dirty(build_state);
     mark_modules_with_deleted_deps_dirty(build_state);
     current_step += 1;
 
@@ -421,12 +417,6 @@ pub fn incremental_build(
         if helpers::contains_ascii_characters(&compile_errors) {
             println!("{}", &compile_errors);
         }
-        // mark the original files as dirty again, because we didn't complete a full build
-        for (module_name, module) in build_state.modules.iter_mut() {
-            if tracked_dirty_modules.contains(module_name) {
-                module.compile_dirty = true;
-            }
-        }
         Err(IncrementalBuildError::CompileError(None))
     } else {
         if show_progress {
@@ -476,8 +466,15 @@ pub fn build(
         None
     };
     let timing_total = Instant::now();
-    let mut build_state = initialize_build(default_timing, filter, show_progress, path, bsc_path)
-        .map_err(|e| anyhow!("Could not initialize build. Error: {e}"))?;
+    let mut build_state = initialize_build(
+        default_timing,
+        filter,
+        show_progress,
+        path,
+        bsc_path,
+        build_dev_deps,
+    )
+    .map_err(|e| anyhow!("Could not initialize build. Error: {e}"))?;
 
     match incremental_build(
         &mut build_state,

rewatch/src/build.rs

@@ -338,10 +338,17 @@ pub fn cleanup_after_build(build_state: &BuildState) {
     });
 }
 
-pub fn clean(path: &str, show_progress: bool, bsc_path: Option<String>) -> Result<()> {
+pub fn clean(path: &str, show_progress: bool, bsc_path: Option<String>, build_dev_deps: bool) -> Result<()> {
     let project_root = helpers::get_abs_path(path);
     let workspace_root = helpers::get_workspace_root(&project_root);
-    let packages = packages::make(&None, &project_root, &workspace_root, show_progress)?;
+    let packages = packages::make(
+        &None,
+        &project_root,
+        &workspace_root,
+        show_progress,
+        // Always clean dev dependencies
+        build_dev_deps,
+    )?;
     let root_config_name = packages::read_package_name(&project_root)?;
     let bsc_path = match bsc_path {
         Some(bsc_path) => helpers::get_abs_path(&bsc_path),

rewatch/src/build/clean.rs

@@ -148,7 +148,7 @@ pub fn compile(
                                 "cmi",
                             );
 
-                            let cmi_digest = helpers::compute_file_hash(&Path::new(&cmi_path));
+                            let cmi_digest = helpers::compute_file_hash(Path::new(&cmi_path));
 
                             let package = build_state
                                 .get_package(&module.package_name)
@@ -189,7 +189,7 @@ pub fn compile(
                                 &build_state.workspace_root,
                                 build_dev_deps,
                             );
-                            let cmi_digest_after = helpers::compute_file_hash(&Path::new(&cmi_path));
+                            let cmi_digest_after = helpers::compute_file_hash(Path::new(&cmi_path));
 
                             // we want to compare both the hash of interface and the implementation
                             // compile assets to verify that nothing changed. We also need to checke the interface
@@ -326,7 +326,7 @@ pub fn compile(
         if files_total_count == compile_universe_count {
             break;
         }
-        if in_progress_modules.len() == 0 || in_progress_modules.eq(&current_in_progres_modules) {
+        if in_progress_modules.is_empty() || in_progress_modules.eq(&current_in_progres_modules) {
             // find the dependency cycle
             let cycle = dependency_cycle::find(
                 &compile_universe
@@ -364,33 +364,10 @@ pub fn compiler_args(
     packages: &Option<&AHashMap<String, packages::Package>>,
     build_dev_deps: bool,
 ) -> Vec<String> {
-    let normal_deps = config.bs_dependencies.as_ref().unwrap_or(&vec![]).to_owned();
-
     let bsc_flags = config::flatten_flags(&config.bsc_flags);
-    // don't compile dev-deps yet
-    let dev_deps = if build_dev_deps {
-        config.bs_dev_dependencies.as_ref().unwrap_or(&vec![]).to_owned()
-    } else {
-        vec![]
-    };
 
-    let deps = [dev_deps, normal_deps]
-        .concat()
-        .par_iter()
-        .map(|package_name| {
-            let canonicalized_path = if let Some(packages) = packages {
-                let package = packages.get(package_name).expect("expect package");
-                package.path.to_string()
-            } else {
-                packages::read_dependency(package_name, project_root, project_root, workspace_root)
-                    .expect("cannot find dep")
-            };
-            vec![
-                "-I".to_string(),
-                packages::get_ocaml_build_path(&canonicalized_path),
-            ]
-        })
-        .collect::<Vec<Vec<String>>>();
+    let dependency_paths =
+        get_dependency_paths(config, project_root, workspace_root, packages, build_dev_deps);
 
     let module_name = helpers::file_path_to_module_name(file_path, &config.get_namespace());
 
@@ -500,7 +477,7 @@ pub fn compiler_args(
         namespace_args,
         read_cmi_args,
         vec!["-I".to_string(), "../ocaml".to_string()],
-        deps.concat(),
+        dependency_paths.concat(),
         uncurried_args,
         bsc_flags.to_owned(),
         warning_args,
@@ -522,6 +499,83 @@ pub fn compiler_args(
     .concat()
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+enum DependentPackage {
+    Normal(String),
+    Dev(String),
+}
+
+impl DependentPackage {
+    fn name(&self) -> &str {
+        match self {
+            Self::Normal(name) => name,
+            Self::Dev(name) => name,
+        }
+    }
+
+    fn is_dev(&self) -> bool {
+        match self {
+            Self::Normal(_) => false,
+            Self::Dev(_) => true,
+        }
+    }
+}
+
+fn get_dependency_paths(
+    config: &config::Config,
+    project_root: &str,
+    workspace_root: &Option<String>,
+    packages: &Option<&AHashMap<String, packages::Package>>,
+    build_dev_deps: bool,
+) -> Vec<Vec<String>> {
+    let normal_deps = config
+        .bs_dependencies
+        .clone()
+        .unwrap_or_default()
+        .into_iter()
+        .map(DependentPackage::Normal)
+        .collect();
+    let dev_deps = if build_dev_deps {
+        config
+            .bs_dev_dependencies
+            .clone()
+            .unwrap_or_default()
+            .into_iter()
+            .map(DependentPackage::Dev)
+            .collect()
+    } else {
+        vec![]
+    };
+
+    [dev_deps, normal_deps]
+        .concat()
+        .par_iter()
+        .filter_map(|dependent_package| {
+            let package_name = dependent_package.name();
+            let dependency_path = if let Some(packages) = packages {
+                packages.get(package_name).map(|package| package.path.to_string())
+            } else {
+                packages::read_dependency(package_name, project_root, project_root, workspace_root).ok()
+            }
+            .map(|canonicalized_path| {
+                vec![
+                    "-I".to_string(),
+                    packages::get_ocaml_build_path(&canonicalized_path),
+                ]
+            });
+
+            if !dependent_package.is_dev() && dependency_path.is_none() {
+                panic!(
+                    "Expected to find dependent package {} of {}",
+                    package_name, config.name
+                );
+            }
+
+            dependency_path
+        })
+        .collect::<Vec<Vec<String>>>()
+}
+
 fn compile_file(
     package: &packages::Package,
     root_package: &packages::Package,

rewatch/src/build/compile.rs

@@ -496,6 +496,7 @@ pub fn get_source_files(
     package_dir: &Path,
     filter: &Option<regex::Regex>,
     source: &config::PackageSource,
+    build_dev_deps: bool,
 ) -> AHashMap<String, SourceFileMeta> {
     let mut map: AHashMap<String, SourceFileMeta> = AHashMap::new();
 
@@ -509,24 +510,19 @@ pub fn get_source_files(
     };
 
     let path_dir = Path::new(&source.dir);
-    // don't include dev sources for now
-    if type_ != &Some("dev".to_string()) {
-        match read_folders(filter, package_dir, path_dir, recurse) {
+    match (build_dev_deps, type_) {
+        (false, Some(type_)) if type_ == "dev" => (),
+        _ => match read_folders(filter, package_dir, path_dir, recurse) {
             Ok(files) => map.extend(files),
-            // Err(_e) if type_ == &Some("dev".to_string()) => {
-            //     log::warn!(
-            //         "Could not read folder: {}... Probably ok as type is dev",
-            //         path_dir.to_string_lossy()
-            //     )
-            // }
+
             Err(_e) => log::error!(
                 "Could not read folder: {:?}. Specified in dependency: {}, located {:?}...",
                 path_dir.to_path_buf().into_os_string(),
                 package_name,
                 package_dir
             ),
-        }
-    }
+        },
+    };
 
     map
 }
@@ -536,13 +532,22 @@ pub fn get_source_files(
 fn extend_with_children(
     filter: &Option<regex::Regex>,
     mut build: AHashMap<String, Package>,
+    build_dev_deps: bool,
 ) -> AHashMap<String, Package> {
     for (_key, package) in build.iter_mut() {
         let mut map: AHashMap<String, SourceFileMeta> = AHashMap::new();
         package
             .source_folders
             .par_iter()
-            .map(|source| get_source_files(&package.name, Path::new(&package.path), filter, source))
+            .map(|source| {
+                get_source_files(
+                    &package.name,
+                    Path::new(&package.path),
+                    filter,
+                    source,
+                    build_dev_deps,
+                )
+            })
             .collect::<Vec<AHashMap<String, SourceFileMeta>>>()
             .into_iter()
             .for_each(|source| map.extend(source));
@@ -584,12 +589,13 @@ pub fn make(
     root_folder: &str,
     workspace_root: &Option<String>,
     show_progress: bool,
+    build_dev_deps: bool,
 ) -> Result<AHashMap<String, Package>> {
     let map = read_packages(root_folder, workspace_root.to_owned(), show_progress)?;
 
     /* Once we have the deduplicated packages, we can add the source files for each - to minimize
      * the IO */
-    let result = extend_with_children(filter, map);
+    let result = extend_with_children(filter, map, build_dev_deps);
 
     Ok(result)
 }