make it work

Author: jfrolich

src/build.rs

@@ -78,9 +78,10 @@ pub fn get_compiler_args(
         };
         helpers::get_rescript_version(&bsc_path)
     };
+
     // make PathBuf from package root and get the relative path for filename
     let relative_filename = PathBuf::from(&filename)
-        .strip_prefix(PathBuf::from(&package_root).parent().unwrap())
+        .strip_prefix(PathBuf::from(&package_root))
         .unwrap()
         .to_string_lossy()
         .to_string();
@@ -108,7 +109,7 @@ pub fn get_compiler_args(
     let compiler_args = compiler_args(
         &rescript_config,
         &root_rescript_config,
-        &ast_path,
+        &ast_path.to_string_lossy(),
         &rescript_version,
         &relative_filename,
         is_interface,

src/build/compile.rs

@@ -162,7 +162,7 @@ pub fn compile(
                                     let result = compile_file(
                                         package,
                                         root_package,
-                                        &package.get_iast_path(&path),
+                                        &helpers::get_ast_path(&path).to_string_lossy(),
                                         module,
                                         &build_state.rescript_version,
                                         true,
@@ -179,7 +179,7 @@ pub fn compile(
                             let result = compile_file(
                                 package,
                                 root_package,
-                                &package.get_ast_path(&source_file.implementation.path),
+                                &helpers::get_ast_path(&source_file.implementation.path).to_string_lossy(),
                                 module,
                                 &build_state.rescript_version,
                                 false,
@@ -415,9 +415,6 @@ pub fn compiler_args(
         packages::Namespace::NoNamespace => vec![],
     };
 
-    let jsx_args = root_config.get_jsx_args();
-    let jsx_module_args = root_config.get_jsx_module_args();
-    let jsx_mode_args = root_config.get_jsx_mode_args();
     let uncurried_args = root_config.get_uncurried_args(version);
     let gentype_arg = root_config.get_gentype_arg();
 
@@ -480,13 +477,10 @@ pub fn compiler_args(
         read_cmi_args,
         vec!["-I".to_string(), ".".to_string()],
         deps.concat(),
-        gentype_arg,
-        jsx_args,
-        jsx_module_args,
-        jsx_mode_args,
         uncurried_args,
         bsc_flags.to_owned(),
         warning_args,
+        gentype_arg,
         // vec!["-warn-error".to_string(), "A".to_string()],
         // ^^ this one fails for bisect-ppx
         // this is the default
@@ -497,6 +491,7 @@ pub fn compiler_args(
         //     "-I".to_string(),
         //     abs_node_modules_path.to_string() + "/rescript/ocaml",
         // ],
+        vec!["-bs-v".to_string(), format!("{}", version)],
         vec![ast_path.to_string()],
     ]
     .concat()
@@ -539,7 +534,6 @@ fn compile_file(
         &Some(packages),
         build_dev_deps,
     );
-
     let to_mjs = Command::new(bsc_path)
         .current_dir(helpers::canonicalize_string_path(&build_path_abs.to_owned()).unwrap())
         .args(to_mjs_args)
@@ -566,35 +560,41 @@ fn compile_file(
             // perhaps we can do this copying somewhere else
             if !is_interface {
                 let _ = std::fs::copy(
-                    build_path_abs.to_string() + "/" + &module_name + ".cmi",
-                    std::path::Path::new(&package.get_bs_build_path())
+                    std::path::Path::new(&package.get_build_path())
                         .join(dir)
                         // because editor tooling doesn't support namespace entries yet
                         // we just remove the @ for now. This makes sure the editor support
                         // doesn't break
                         .join(module_name.to_owned() + ".cmi"),
+                    build_path_abs.to_string() + "/" + &module_name + ".cmi",
                 );
                 let _ = std::fs::copy(
-                    build_path_abs.to_string() + "/" + &module_name + ".cmj",
-                    std::path::Path::new(&package.get_bs_build_path())
+                    std::path::Path::new(&package.get_build_path())
                         .join(dir)
                         .join(module_name.to_owned() + ".cmj"),
+                    build_path_abs.to_string() + "/" + &module_name + ".cmj",
                 );
                 let _ = std::fs::copy(
-                    build_path_abs.to_string() + "/" + &module_name + ".cmt",
-                    std::path::Path::new(&package.get_bs_build_path())
+                    std::path::Path::new(&package.get_build_path())
                         .join(dir)
                         // because editor tooling doesn't support namespace entries yet
                         // we just remove the @ for now. This makes sure the editor support
                         // doesn't break
                         .join(module_name.to_owned() + ".cmt"),
+                    build_path_abs.to_string() + "/" + &module_name + ".cmt",
                 );
             } else {
                 let _ = std::fs::copy(
-                    build_path_abs.to_string() + "/" + &module_name + ".cmti",
-                    std::path::Path::new(&package.get_bs_build_path())
+                    std::path::Path::new(&package.get_build_path())
                         .join(dir)
                         .join(module_name.to_owned() + ".cmti"),
+                    build_path_abs.to_string() + "/" + &module_name + ".cmti",
+                );
+                let _ = std::fs::copy(
+                    std::path::Path::new(&package.get_build_path())
+                        .join(dir)
+                        .join(module_name.to_owned() + ".cmi"),
+                    build_path_abs.to_string() + "/" + &module_name + ".cmi",
                 );
             }
             match &module.source_type {
@@ -617,7 +617,7 @@ fn compile_file(
 
                     let _ = std::fs::copy(
                         std::path::Path::new(&package.path).join(path),
-                        std::path::Path::new(&package.get_build_path())
+                        std::path::Path::new(&package.get_bs_build_path())
                             .join(std::path::Path::new(path).file_name().unwrap()),
                     )
                     .expect("copying source file failed");

src/build/deps.rs

@@ -10,8 +10,10 @@ fn get_dep_modules(
     namespace: Option<String>,
     package_modules: &AHashSet<String>,
     valid_modules: &AHashSet<String>,
+    package: &packages::Package,
 ) -> AHashSet<String> {
     let mut deps = AHashSet::new();
+    let ast_file = package.get_build_path() + "/" + ast_file;
     if let Ok(lines) = helpers::read_lines(ast_file.to_string()) {
         // we skip the first line with is some null characters
         // the following lines in the AST are the dependency modules
@@ -75,23 +77,25 @@ pub fn get_deps(build_state: &mut BuildState, deleted_modules: &AHashSet<String>
                 let package = build_state
                     .get_package(&module.package_name)
                     .expect("Package not found");
-                let ast_path = package.get_ast_path(&source_file.implementation.path);
+                let ast_path = helpers::get_ast_path(&source_file.implementation.path);
                 if is_dirty(module) || !build_state.deps_initialized {
                     let mut deps = get_dep_modules(
-                        &ast_path,
+                        &ast_path.to_string_lossy(),
                         package.namespace.to_suffix(),
                         package.modules.as_ref().unwrap(),
                         all_mod,
+                        &package,
                     );
 
                     if let Some(interface) = &source_file.interface {
-                        let iast_path = package.get_iast_path(&interface.path);
+                        let iast_path = helpers::get_ast_path(&interface.path);
 
                         deps.extend(get_dep_modules(
-                            &iast_path,
+                            &iast_path.to_string_lossy(),
                             package.namespace.to_suffix(),
                             package.modules.as_ref().unwrap(),
                             all_mod,
+                            &package,
                         ))
                     }
                     match &package.namespace {

src/build/packages.rs

@@ -94,14 +94,6 @@ impl Package {
                 .expect("namespace should be set for mlmap module")
             + ".cmi"
     }
-
-    pub fn get_ast_path(&self, source_file: &str) -> String {
-        helpers::get_compiler_asset(self, &packages::Namespace::NoNamespace, source_file, "ast")
-    }
-
-    pub fn get_iast_path(&self, source_file: &str) -> String {
-        helpers::get_compiler_asset(self, &packages::Namespace::NoNamespace, source_file, "iast")
-    }
 }
 
 impl PartialEq for Package {

src/build/parse.rs

@@ -29,7 +29,12 @@ pub fn generate_asts(
             match &module.source_type {
                 SourceType::MlMap(_mlmap) => {
                     let path = package.get_mlmap_path();
-                    (module_name.to_owned(), Ok((path, None)), Ok(None), false)
+                    (
+                        module_name.to_owned(),
+                        Ok((Path::new(&path).to_path_buf(), None)),
+                        Ok(None),
+                        false,
+                    )
                 }
 
                 SourceType::SourceFile(source_file) => {
@@ -69,13 +74,20 @@ pub fn generate_asts(
                     } else {
                         (
                             Ok((
-                                helpers::get_basename(&source_file.implementation.path).to_string() + ".ast",
+                                Path::new(
+                                    &(helpers::get_basename(&source_file.implementation.path).to_string()
+                                        + ".ast"),
+                                )
+                                .to_path_buf(),
                                 None,
                             )),
-                            Ok(source_file
-                                .interface
-                                .as_ref()
-                                .map(|i| (helpers::get_basename(&i.path).to_string() + ".iast", None))),
+                            Ok(source_file.interface.as_ref().map(|i| {
+                                (
+                                    Path::new(&(helpers::get_basename(&i.path).to_string() + ".iast"))
+                                        .to_path_buf(),
+                                    None,
+                                )
+                            })),
                             false,
                         )
                     };
@@ -86,8 +98,8 @@ pub fn generate_asts(
         })
         .collect::<Vec<(
             String,
-            Result<(String, Option<helpers::StdErr>), String>,
-            Result<Option<(String, Option<helpers::StdErr>)>, String>,
+            Result<(PathBuf, Option<helpers::StdErr>), String>,
+            Result<Option<(PathBuf, Option<helpers::StdErr>)>, String>,
             bool,
         )>>()
         .into_iter()
@@ -255,11 +267,14 @@ pub fn parser_args(
     workspace_root: &Option<String>,
     root_path: &str,
     contents: &str,
-) -> (String, Vec<String>) {
+) -> (PathBuf, Vec<String>) {
     let file = &filename.to_string();
-    let path = PathBuf::from(filename);
-    let ast_extension = path_to_ast_extension(&path);
-    let ast_path = (helpers::get_basename(&file.to_string()).to_owned()) + ast_extension;
+    // let path = PathBuf::from(filename);
+    // let ast_extension = path_to_ast_extension(&path);
+    // let ast_path = (helpers::get_basename(&file.to_string()).to_owned()) + ast_extension;
+    let ast_path = helpers::get_ast_path(file);
+    // make the dir of the ast_path if it doesn't exist yet:
+
     let ppx_flags = config::flatten_ppx_flags(
         &if let Some(workspace_root) = workspace_root {
             format!("{}/node_modules", &workspace_root)
@@ -277,7 +292,7 @@ pub fn parser_args(
 
     let file = "../../".to_string() + file;
     (
-        ast_path.to_string(),
+        ast_path.to_owned(),
         [
             vec!["-bs-v".to_string(), format!("{}", version)],
             ppx_flags,
@@ -290,7 +305,7 @@ pub fn parser_args(
                 "-absname".to_string(),
                 "-bs-ast".to_string(),
                 "-o".to_string(),
-                ast_path.to_string(),
+                ast_path.to_string_lossy().to_string(),
                 file,
             ],
         ]
@@ -305,7 +320,7 @@ fn generate_ast(
     version: &str,
     bsc_path: &str,
     workspace_root: &Option<String>,
-) -> Result<(String, Option<helpers::StdErr>), String> {
+) -> Result<(PathBuf, Option<helpers::StdErr>), String> {
     let file_path = PathBuf::from(&package.path).join(filename);
     let contents = helpers::read_file(&file_path).expect("Error reading file");
 
@@ -320,6 +335,11 @@ fn generate_ast(
         &contents,
     );
 
+    // generate the dir of the ast_path (it mirrors the source file dir)
+    helpers::create_build_path(
+        &(package.get_build_path() + "/" + &ast_path.parent().unwrap().to_string_lossy()),
+    );
+
     /* Create .ast */
     let result = if let Some(res_to_ast) = Some(
         Command::new(bsc_path)
@@ -347,26 +367,15 @@ fn generate_ast(
         ))
     };
     if let Ok((ast_path, _)) = &result {
-        let dir = std::path::Path::new(filename).parent().unwrap();
+        // let dir = std::path::Path::new(filename).parent().unwrap();
         let _ = std::fs::copy(
-            build_path_abs.to_string() + "/" + ast_path,
-            std::path::Path::new(&package.get_bs_build_path())
-                .join(dir)
-                .join(ast_path),
+            Path::new(&build_path_abs).join(&ast_path),
+            std::path::Path::new(&package.get_build_path()).join(ast_path.file_name().unwrap()),
         );
     }
     result
 }
 
-fn path_to_ast_extension(path: &Path) -> &str {
-    let extension = path.extension().unwrap().to_str().unwrap();
-    if helpers::is_interface_ast_file(extension) {
-        ".iast"
-    } else {
-        ".ast"
-    }
-}
-
 fn include_ppx(flag: &str, contents: &str) -> bool {
     if flag.contains("bisect") {
         return std::env::var("BISECT_ENABLE").is_ok();

src/helpers.rs

@@ -184,6 +184,24 @@ pub fn string_ends_with_any(s: &Path, suffixes: &[&str]) -> bool {
         .any(|&suffix| s.extension().unwrap_or(&OsString::new()).to_str().unwrap_or("") == suffix)
 }
 
+fn path_to_ast_extension(path: &Path) -> &str {
+    let extension = path.extension().unwrap().to_str().unwrap();
+    if extension.ends_with("i") {
+        ".iast"
+    } else {
+        ".ast"
+    }
+}
+
+pub fn get_ast_path(source_file: &str) -> PathBuf {
+    let source_path = Path::new(source_file);
+
+    source_path.parent().unwrap().join(
+        file_path_to_compiler_asset_basename(source_file, &packages::Namespace::NoNamespace)
+            + path_to_ast_extension(source_path),
+    )
+}
+
 pub fn get_compiler_asset(
     package: &packages::Package,
     namespace: &packages::Namespace,
@@ -201,11 +219,8 @@ pub fn get_compiler_asset(
         + extension
 }
 
-pub fn canonicalize_string_path(path: &str) -> Option<String> {
-    return Path::new(path)
-        .canonicalize()
-        .ok()
-        .map(|path| path.to_str().expect("Could not canonicalize").to_string());
+pub fn canonicalize_string_path(path: &str) -> Option<PathBuf> {
+    return Path::new(path).canonicalize().ok();
 }
 
 pub fn get_bs_compiler_asset(