summaryrefslogtreecommitdiff
path: root/cli/graph.rs
diff options
context:
space:
mode:
Diffstat (limited to 'cli/graph.rs')
-rw-r--r--cli/graph.rs127
1 files changed, 123 insertions, 4 deletions
diff --git a/cli/graph.rs b/cli/graph.rs
index 9025df185..d3f05c5f4 100644
--- a/cli/graph.rs
+++ b/cli/graph.rs
@@ -16,6 +16,7 @@ use crate::specifier_handler::FetchFuture;
use crate::specifier_handler::SpecifierHandler;
use crate::tsc_config::IgnoredCompilerOptions;
use crate::tsc_config::TsConfig;
+use crate::version;
use crate::AnyError;
use deno_core::futures::stream::FuturesUnordered;
@@ -163,6 +164,17 @@ fn parse_deno_types(comment: &str) -> Option<String> {
}
}
+/// A hashing function that takes the source code, version and optionally a
+/// user provided config and generates a string hash which can be stored to
+/// determine if the cached emit is valid or not.
+fn get_version(source: &TextDocument, version: &str, config: &[u8]) -> String {
+ crate::checksum::gen(&[
+ source.to_str().unwrap().as_bytes(),
+ version.as_bytes(),
+ config,
+ ])
+}
+
/// A logical representation of a module within a graph.
#[derive(Debug, Clone)]
struct Module {
@@ -174,6 +186,7 @@ struct Module {
maybe_import_map: Option<Rc<RefCell<ImportMap>>>,
maybe_parsed_module: Option<ParsedModule>,
maybe_types: Option<(String, ModuleSpecifier)>,
+ maybe_version: Option<String>,
media_type: MediaType,
specifier: ModuleSpecifier,
source: TextDocument,
@@ -190,6 +203,7 @@ impl Default for Module {
maybe_import_map: None,
maybe_parsed_module: None,
maybe_types: None,
+ maybe_version: None,
media_type: MediaType::Unknown,
specifier: ModuleSpecifier::resolve_url("https://deno.land/x/").unwrap(),
source: TextDocument::new(Vec::new(), Option::<&str>::None),
@@ -209,6 +223,16 @@ impl Module {
}
}
+ /// Return `true` if the current hash of the module matches the stored
+ /// version.
+ pub fn emit_valid(&self, config: &[u8]) -> bool {
+ if let Some(version) = self.maybe_version.clone() {
+ version == get_version(&self.source, version::DENO, config)
+ } else {
+ false
+ }
+ }
+
pub fn hydrate(&mut self, cached_module: CachedModule) {
self.media_type = cached_module.media_type;
self.source = cached_module.source;
@@ -230,6 +254,7 @@ impl Module {
};
self.is_dirty = false;
self.emits = cached_module.emits;
+ self.maybe_version = cached_module.maybe_version;
self.is_hydrated = true;
}
@@ -351,6 +376,11 @@ impl Module {
Ok(specifier)
}
+
+ /// Calculate the hashed version of the module and update the `maybe_version`.
+ pub fn set_version(&mut self, config: &[u8]) {
+ self.maybe_version = Some(get_version(&self.source, version::DENO, config))
+ }
}
#[derive(Clone, Debug, PartialEq)]
@@ -428,6 +458,9 @@ impl Graph {
maybe_map.clone(),
)?;
module.is_dirty = false;
+ if let Some(version) = &module.maybe_version {
+ handler.set_version(&module.specifier, version.clone())?;
+ }
}
}
for root_specifier in self.roots.iter() {
@@ -508,14 +541,14 @@ impl Graph {
let mut emit_count: u128 = 0;
for (_, module) in self.modules.iter_mut() {
+ // TODO(kitsonk) a lot of this logic should be refactored into `Module` as
+ // we start to support other methods on the graph. Especially managing
+ // the dirty state is something the module itself should "own".
+
// if the module is a Dts file we should skip it
if module.media_type == MediaType::Dts {
continue;
}
- // skip modules that already have a valid emit
- if module.emits.contains_key(&emit_type) {
- continue;
- }
// if we don't have check_js enabled, we won't touch non TypeScript
// modules
if !(check_js
@@ -524,6 +557,11 @@ impl Graph {
{
continue;
}
+ let config = ts_config.as_bytes();
+ // skip modules that already have a valid emit
+ if module.emits.contains_key(&emit_type) && module.emit_valid(&config) {
+ continue;
+ }
if module.maybe_parsed_module.is_none() {
module.parse()?;
}
@@ -531,6 +569,7 @@ impl Graph {
let emit = parsed_module.transpile(&emit_options)?;
emit_count += 1;
module.emits.insert(emit_type.clone(), emit);
+ module.set_version(&config);
module.is_dirty = true;
}
self.flush(&emit_type)?;
@@ -736,6 +775,86 @@ mod tests {
use std::path::PathBuf;
use std::sync::Mutex;
+ #[test]
+ fn test_get_version() {
+ let doc_a =
+ TextDocument::new(b"console.log(42);".to_vec(), Option::<&str>::None);
+ let version_a = get_version(&doc_a, "1.2.3", b"");
+ let doc_b =
+ TextDocument::new(b"console.log(42);".to_vec(), Option::<&str>::None);
+ let version_b = get_version(&doc_b, "1.2.3", b"");
+ assert_eq!(version_a, version_b);
+
+ let version_c = get_version(&doc_a, "1.2.3", b"options");
+ assert_ne!(version_a, version_c);
+
+ let version_d = get_version(&doc_b, "1.2.3", b"options");
+ assert_eq!(version_c, version_d);
+
+ let version_e = get_version(&doc_a, "1.2.4", b"");
+ assert_ne!(version_a, version_e);
+
+ let version_f = get_version(&doc_b, "1.2.4", b"");
+ assert_eq!(version_e, version_f);
+ }
+
+ #[test]
+ fn test_module_emit_valid() {
+ let source =
+ TextDocument::new(b"console.log(42);".to_vec(), Option::<&str>::None);
+ let maybe_version = Some(get_version(&source, version::DENO, b""));
+ let module = Module {
+ source,
+ maybe_version,
+ ..Module::default()
+ };
+ assert!(module.emit_valid(b""));
+
+ let source =
+ TextDocument::new(b"console.log(42);".to_vec(), Option::<&str>::None);
+ let old_source =
+ TextDocument::new(b"console.log(43);".to_vec(), Option::<&str>::None);
+ let maybe_version = Some(get_version(&old_source, version::DENO, b""));
+ let module = Module {
+ source,
+ maybe_version,
+ ..Module::default()
+ };
+ assert!(!module.emit_valid(b""));
+
+ let source =
+ TextDocument::new(b"console.log(42);".to_vec(), Option::<&str>::None);
+ let maybe_version = Some(get_version(&source, "0.0.0", b""));
+ let module = Module {
+ source,
+ maybe_version,
+ ..Module::default()
+ };
+ assert!(!module.emit_valid(b""));
+
+ let source =
+ TextDocument::new(b"console.log(42);".to_vec(), Option::<&str>::None);
+ let module = Module {
+ source,
+ ..Module::default()
+ };
+ assert!(!module.emit_valid(b""));
+ }
+
+ #[test]
+ fn test_module_set_version() {
+ let source =
+ TextDocument::new(b"console.log(42);".to_vec(), Option::<&str>::None);
+ let expected = Some(get_version(&source, version::DENO, b""));
+ let mut module = Module {
+ source,
+ ..Module::default()
+ };
+ assert!(module.maybe_version.is_none());
+ module.set_version(b"");
+ assert_eq!(module.maybe_version, expected);
+ }
+
#[tokio::test]
async fn test_graph_builder() {
let c = PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").unwrap());