Fixed export package-definitions not including cached modules

Signed-off-by: Pedro H C Francisco <[email protected]>

Author: mine-tech-oficial

compiler-core/src/build.rs

@@ -20,6 +20,7 @@ use crate::ast::{
     CallArg, CustomType, DefinitionLocation, Pattern, TypeAst, TypedArg, TypedDefinition,
     TypedExpr, TypedFunction, TypedPattern, TypedStatement,
 };
+use crate::package_interface;
 use crate::type_::Type;
 use crate::{
     ast::{Definition, SrcSpan, TypedModule},
@@ -208,6 +209,7 @@ fn mode_includes_tests() {
 pub struct Package {
     pub config: PackageConfig,
     pub modules: Vec<Module>,
+    pub cached_metadata: Vec<package_compiler::CacheMetadata>,
 }
 
 impl Package {
@@ -225,7 +227,7 @@ impl Package {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Module {
     pub name: EcoString,
     pub code: EcoString,

compiler-core/src/build/module_loader.rs

@@ -84,7 +84,7 @@ where
             }
         }
 
-        Ok(Input::Cached(self.cached(name, meta)))
+        Ok(Input::Cached((self.cached(name, meta.clone()), meta)))
     }
 
     /// Read the timestamp file from the artefact directory for the given

compiler-core/src/build/module_loader/tests.rs

@@ -3,6 +3,7 @@ use crate::{
     build::SourceFingerprint,
     io::{memory::InMemoryFileSystem, FileSystemWriter},
     line_numbers::LineNumbers,
+    package_interface,
 };
 use std::time::Duration;
 
@@ -212,11 +213,13 @@ fn write_cache(
 ) {
     let line_numbers = LineNumbers::new(source);
     let cache_metadata = CacheMetadata {
+        name: "".into(),
         mtime: SystemTime::UNIX_EPOCH + Duration::from_secs(seconds),
         codegen_performed,
         dependencies: vec![],
         fingerprint: SourceFingerprint::new(source),
         line_numbers,
+        interface: package_interface::ModuleInterface::default(),
     };
     let path = Utf8Path::new(path);
     fs.write_bytes(&path, &cache_metadata.to_binary()).unwrap();

compiler-core/src/build/package_compiler.rs

@@ -1,5 +1,6 @@
 use crate::analyse::{ModuleAnalyzerConstructor, TargetSupport};
 use crate::line_numbers::{self, LineNumbers};
+use crate::package_interface::{self, ModuleInterface};
 use crate::type_::PRELUDE_MODULE_NAME;
 use crate::{
     ast::{SrcSpan, TypedModule, UntypedModule},
@@ -22,6 +23,7 @@ use crate::{
 };
 use askama::Template;
 use ecow::EcoString;
+use std::borrow::BorrowMut;
 use std::collections::HashSet;
 use std::{collections::HashMap, fmt::write, time::SystemTime};
 use vec1::Vec1;
@@ -104,7 +106,7 @@ where
         stale_modules: &mut StaleTracker,
         incomplete_modules: &mut HashSet<EcoString>,
         telemetry: &dyn Telemetry,
-    ) -> Outcome<Vec<Module>, Error> {
+    ) -> Outcome<(Vec<Module>, Vec<CacheMetadata>), Error> {
         let span = tracing::info_span!("compile", package = %self.config.name.as_str());
         let _enter = span.enter();
 
@@ -168,6 +170,8 @@ where
             }
         }
 
+        println!("{:?}", loaded.cached_metadata);
+
         // Type check the modules that are new or have changed
         tracing::info!(count=%loaded.to_compile.len(), "analysing_modules");
         let outcome = analyse(
@@ -182,9 +186,12 @@ where
             incomplete_modules,
         );
 
-        let modules = match outcome {
+        let mut modules = match outcome {
             Outcome::Ok(modules) => modules,
-            Outcome::PartialFailure(_, _) | Outcome::TotalFailure(_) => return outcome,
+            Outcome::PartialFailure(modules, err) => {
+                return Outcome::PartialFailure((modules, loaded.cached_metadata), err)
+            }
+            Outcome::TotalFailure(err) => return Outcome::TotalFailure(err),
         };
 
         tracing::debug!("performing_code_generation");
@@ -197,7 +204,7 @@ where
             return error.into();
         }
 
-        Outcome::Ok(modules)
+        Outcome::Ok((modules, loaded.cached_metadata))
     }
 
     fn compile_erlang_to_beam(&mut self, modules: &HashSet<Utf8PathBuf>) -> Result<(), Error> {
@@ -304,11 +311,13 @@ where
             let name = format!("{}.cache_meta", &module_name);
             let path = artefact_dir.join(name);
             let info = CacheMetadata {
+                name: module.name.clone(),
                 mtime: module.mtime,
                 codegen_performed: self.perform_codegen,
                 dependencies: module.dependencies.clone(),
                 fingerprint: SourceFingerprint::new(&module.code),
                 line_numbers: module.ast.type_info.line_numbers.clone(),
+                interface: package_interface::ModuleInterface::from_module(module),
             };
             self.io.write_bytes(&path, &info.to_binary())?;
 
@@ -594,28 +603,28 @@ pub(crate) fn module_name(package_path: &Utf8Path, full_module_path: &Utf8Path)
 #[derive(Debug)]
 pub(crate) enum Input {
     New(UncompiledModule),
-    Cached(CachedModule),
+    Cached((CachedModule, CacheMetadata)),
 }
 
 impl Input {
     pub fn name(&self) -> &EcoString {
         match self {
             Input::New(m) => &m.name,
-            Input::Cached(m) => &m.name,
+            Input::Cached(m) => &m.0.name,
         }
     }
 
     pub fn source_path(&self) -> &Utf8Path {
         match self {
             Input::New(m) => &m.path,
-            Input::Cached(m) => &m.source_path,
+            Input::Cached(m) => &m.0.source_path,
         }
     }
 
     pub fn dependencies(&self) -> Vec<EcoString> {
         match self {
             Input::New(m) => m.dependencies.iter().map(|(n, _)| n.clone()).collect(),
-            Input::Cached(m) => m.dependencies.iter().map(|(n, _)| n.clone()).collect(),
+            Input::Cached(m) => m.0.dependencies.iter().map(|(n, _)| n.clone()).collect(),
         }
     }
 
@@ -645,13 +654,15 @@ pub(crate) struct CachedModule {
     pub line_numbers: LineNumbers,
 }
 
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
-pub(crate) struct CacheMetadata {
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+pub struct CacheMetadata {
+    pub name: EcoString,
     pub mtime: SystemTime,
     pub codegen_performed: bool,
     pub dependencies: Vec<(EcoString, SrcSpan)>,
     pub fingerprint: SourceFingerprint,
     pub line_numbers: LineNumbers,
+    pub interface: package_interface::ModuleInterface,
 }
 
 impl CacheMetadata {
@@ -664,22 +675,24 @@ impl CacheMetadata {
     }
 }
 
-#[derive(Debug, Default, PartialEq, Eq)]
+#[derive(Debug, Default)]
 pub(crate) struct Loaded {
     pub to_compile: Vec<UncompiledModule>,
     pub cached: Vec<type_::ModuleInterface>,
+    pub cached_metadata: Vec<CacheMetadata>,
 }
 
 impl Loaded {
     fn empty() -> Self {
         Self {
             to_compile: vec![],
             cached: vec![],
+            cached_metadata: vec![],
         }
     }
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub(crate) struct UncompiledModule {
     pub path: Utf8PathBuf,
     pub name: EcoString,

compiler-core/src/build/package_loader.rs

@@ -148,19 +148,20 @@ where
                 // A cached module with dependencies that are stale must be
                 // recompiled as the changes in the dependencies may have affect
                 // the output, making the cache invalid.
-                Input::Cached(info) if self.stale_modules.includes_any(&info.dependencies) => {
-                    tracing::debug!(module = %info.name, "module_to_be_compiled");
-                    self.stale_modules.add(info.name.clone());
-                    let module = self.load_and_parse(info)?;
+                Input::Cached(info) if self.stale_modules.includes_any(&info.0.dependencies) => {
+                    tracing::debug!(module = %info.0.name, "module_to_be_compiled");
+                    self.stale_modules.add(info.0.name.clone());
+                    let module = self.load_and_parse(info.0)?;
                     loaded.to_compile.push(module);
                 }
 
                 // A cached module with no stale dependencies can be used as-is
                 // and does not need to be recompiled.
                 Input::Cached(info) => {
-                    tracing::debug!(module = %info.name, "module_to_load_from_cache");
-                    let module = self.load_cached_module(info)?;
+                    tracing::debug!(module = %info.0.name, "module_to_load_from_cache");
+                    let module = self.load_cached_module(info.0)?;
                     loaded.cached.push(module);
+                    loaded.cached_metadata.push(info.1);
                 }
             }
         }
@@ -324,7 +325,7 @@ where
                                     src: module.code.clone(),
                                 }
                             }
-                            Input::Cached(cached_module) => {
+                            Input::Cached((cached_module, _)) => {
                                 let (_, location) = cached_module
                                     .dependencies
                                     .iter()

compiler-core/src/build/package_loader/tests.rs

@@ -5,7 +5,7 @@ use super::*;
 use crate::{
     build::SourceFingerprint,
     io::{memory::InMemoryFileSystem, FileSystemWriter},
-    line_numbers,
+    line_numbers, package_interface,
     parse::extra::ModuleExtra,
     warning::NullWarningEmitterIO,
     Warning,
@@ -39,11 +39,13 @@ fn write_cache(
     let line_numbers = line_numbers::LineNumbers::new(src);
     let mtime = SystemTime::UNIX_EPOCH + Duration::from_secs(seconds);
     let cache_metadata = CacheMetadata {
+        name: name.into(),
         mtime,
         codegen_performed: true,
         dependencies: deps,
         fingerprint: SourceFingerprint::new(src),
         line_numbers: line_numbers.clone(),
+        interface: package_interface::ModuleInterface::default(),
     };
     let path = Utf8Path::new("/artefact").join(format!("{name}.cache_meta"));
     fs.write_bytes(&path, &cache_metadata.to_binary()).unwrap();
@@ -62,7 +64,7 @@ fn write_cache(
         warnings: vec![],
         minimum_required_version: Version::new(0, 1, 0),
     };
-    let path = Utf8Path::new("/artefact").join(format!("{name}.cache"));
+    let path: Utf8PathBuf = Utf8Path::new("/artefact").join(format!("{name}.cache"));
     fs.write_bytes(
         &path,
         &metadata::ModuleEncoder::new(&cache).encode().unwrap(),

compiler-core/src/build/project_compiler.rs

@@ -21,7 +21,7 @@ use crate::{
 use ecow::EcoString;
 use hexpm::version::Version;
 use itertools::Itertools;
-use pubgrub::range::Range;
+use pubgrub::{package, range::Range};
 use std::{
     cmp,
     collections::{HashMap, HashSet},
@@ -208,7 +208,11 @@ where
     pub fn compile_root_package(&mut self) -> Outcome<Package, Error> {
         let config = self.config.clone();
         self.compile_gleam_package(&config, true, self.paths.root().to_path_buf())
-            .map(|modules| Package { config, modules })
+            .map(|(modules, cached_metadata)| Package {
+                config,
+                modules,
+                cached_metadata,
+            })
     }
 
     /// Checks that version file found in the build directory matches the
@@ -288,7 +292,9 @@ where
         // longer need to have the package borrowed from self.packages.
         let package = self.packages.get(name).expect("Missing package").clone();
         let result = match usable_build_tools(&package)?.as_slice() {
-            &[BuildTool::Gleam] => self.compile_gleam_dep_package(&package),
+            &[BuildTool::Gleam] => self
+                .compile_gleam_dep_package(&package)
+                .map(|(modules, _)| modules),
             &[BuildTool::Rebar3] => self.compile_rebar3_dep_package(&package).map(|_| vec![]),
             &[BuildTool::Mix] => self.compile_mix_dep_package(&package).map(|_| vec![]),
             &[BuildTool::Mix, BuildTool::Rebar3] => self
@@ -489,7 +495,7 @@ where
     fn compile_gleam_dep_package(
         &mut self,
         package: &ManifestPackage,
-    ) -> Result<Vec<Module>, Error> {
+    ) -> Result<(Vec<Module>, Vec<package_compiler::CacheMetadata>), Error> {
         // TODO: Test
         let package_root = match &package.source {
             // If the path is relative it is relative to the root of the
@@ -520,7 +526,7 @@ where
         config: &PackageConfig,
         is_root: bool,
         root_path: Utf8PathBuf,
-    ) -> Outcome<Vec<Module>, Error> {
+    ) -> Outcome<(Vec<Module>, Vec<package_compiler::CacheMetadata>), Error> {
         let out_path =
             self.paths
                 .build_directory_for_package(self.mode(), self.target(), &config.name);
@@ -590,14 +596,16 @@ where
         };
 
         // Compile project to Erlang or JavaScript source code
-        compiler.compile(
+        let outcome = compiler.compile(
             &mut self.warnings,
             &mut self.importable_modules,
             &mut self.defined_modules,
             &mut self.stale_modules,
             &mut self.incomplete_modules,
             self.telemetry,
-        )
+        );
+
+        outcome
     }
 }
 

compiler-core/src/docs/tests.rs

@@ -63,7 +63,7 @@ fn compile_with_markdown_pages(
         )
         .unwrap();
 
-    for module in &mut modules {
+    for module in &mut modules.0 {
         module.attach_doc_and_module_comments();
     }
 
@@ -79,7 +79,7 @@ fn compile_with_markdown_pages(
     super::generate_html(
         &paths,
         &config,
-        &modules,
+        &modules.0,
         &docs_pages,
         pages_fs,
         SystemTime::UNIX_EPOCH,