0
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-10-29 08:58:01 -04:00
denoland-deno/cli/compiler.rs

312 lines
9.2 KiB
Rust
Raw Normal View History

// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
use crate::diagnostics::Diagnostic;
2019-01-14 01:30:38 -05:00
use crate::msg;
use crate::resources;
use crate::startup_data;
use crate::state::*;
2019-04-05 00:04:06 -04:00
use crate::tokio_util;
use crate::worker::Worker;
use deno::js_check;
2019-03-30 19:30:40 -04:00
use deno::Buf;
use futures::Future;
use futures::Stream;
2019-02-18 10:42:15 -05:00
use std::str;
use std::sync::atomic::Ordering;
// This corresponds to JS ModuleMetaData.
// TODO Rename one or the other so they correspond.
#[derive(Debug, Clone)]
2019-02-18 10:42:15 -05:00
pub struct ModuleMetaData {
pub module_name: String,
pub module_redirect_source_name: Option<String>, // source of redirect
pub filename: String,
pub media_type: msg::MediaType,
2019-02-18 10:42:15 -05:00
pub source_code: Vec<u8>,
pub maybe_output_code_filename: Option<String>,
2019-02-18 10:42:15 -05:00
pub maybe_output_code: Option<Vec<u8>>,
pub maybe_source_map_filename: Option<String>,
2019-02-18 10:42:15 -05:00
pub maybe_source_map: Option<Vec<u8>>,
}
2019-02-18 10:42:15 -05:00
impl ModuleMetaData {
pub fn has_output_code_and_source_map(&self) -> bool {
self.maybe_output_code.is_some() && self.maybe_source_map.is_some()
}
pub fn js_source(&self) -> String {
if self.media_type == msg::MediaType::Json {
2019-02-18 10:42:15 -05:00
return format!(
"export default {};",
str::from_utf8(&self.source_code).unwrap()
);
}
match self.maybe_output_code {
2019-02-18 10:42:15 -05:00
None => str::from_utf8(&self.source_code).unwrap().to_string(),
Some(ref output_code) => str::from_utf8(output_code).unwrap().to_string(),
}
}
}
type CompilerConfig = Option<(String, Vec<u8>)>;
/// Creates the JSON message send to compiler.ts's onmessage.
2019-06-08 14:42:28 -04:00
fn req(
root_names: Vec<String>,
compiler_config: CompilerConfig,
bundle: Option<String>,
) -> Buf {
let j = if let Some((config_path, config_data)) = compiler_config {
json!({
"rootNames": root_names,
2019-06-08 14:42:28 -04:00
"bundle": bundle,
"configPath": config_path,
"config": str::from_utf8(&config_data).unwrap(),
})
} else {
json!({
"rootNames": root_names,
2019-06-08 14:42:28 -04:00
"bundle": bundle,
})
};
j.to_string().into_boxed_str().into_boxed_bytes()
}
/// Returns an optional tuple which represents the state of the compiler
/// configuration where the first is canonical name for the configuration file
/// and a vector of the bytes of the contents of the configuration file.
pub fn get_compiler_config(
parent_state: &ThreadSafeState,
_compiler_type: &str,
) -> CompilerConfig {
// The compiler type is being passed to make it easier to implement custom
// compilers in the future.
match (&parent_state.config_path, &parent_state.config) {
(Some(config_path), Some(config)) => {
Some((config_path.to_string(), config.to_vec()))
}
_ => None,
}
}
2019-06-08 14:42:28 -04:00
pub fn bundle_async(
state: ThreadSafeState,
module_name: String,
out_file: String,
) -> impl Future<Item = (), Error = Diagnostic> {
debug!(
"Invoking the compiler to bundle. module_name: {}",
module_name
);
let root_names = vec![module_name.clone()];
let compiler_config = get_compiler_config(&state, "typescript");
let req_msg = req(root_names, compiler_config, Some(out_file));
// Count how many times we start the compiler worker.
state.metrics.compiler_starts.fetch_add(1, Ordering::SeqCst);
let mut worker = Worker::new(
"TS".to_string(),
startup_data::compiler_isolate_init(),
// TODO(ry) Maybe we should use a separate state for the compiler.
// as was done previously.
state.clone(),
);
js_check(worker.execute("denoMain()"));
js_check(worker.execute("workerMain()"));
js_check(worker.execute("compilerMain()"));
let resource = worker.state.resource.clone();
let compiler_rid = resource.rid;
let first_msg_fut = resources::post_message_to_worker(compiler_rid, req_msg)
.then(move |_| worker)
.then(move |result| {
if let Err(err) = result {
// TODO(ry) Need to forward the error instead of exiting.
eprintln!("{}", err.to_string());
std::process::exit(1);
}
debug!("Sent message to worker");
let stream_future =
resources::get_message_stream_from_worker(compiler_rid).into_future();
stream_future.map(|(f, _rest)| f).map_err(|(f, _rest)| f)
});
first_msg_fut.map_err(|_| panic!("not handled")).and_then(
move |maybe_msg: Option<Buf>| {
debug!("Received message from worker");
if let Some(msg) = maybe_msg {
let json_str = std::str::from_utf8(&msg).unwrap();
debug!("Message: {}", json_str);
if let Some(diagnostics) = Diagnostic::from_emit_result(json_str) {
return Err(diagnostics);
}
}
Ok(())
},
)
}
2019-04-05 00:04:06 -04:00
pub fn compile_async(
state: ThreadSafeState,
2019-02-18 10:42:15 -05:00
module_meta_data: &ModuleMetaData,
) -> impl Future<Item = ModuleMetaData, Error = Diagnostic> {
2019-06-06 20:37:26 -04:00
let module_name = module_meta_data.module_name.clone();
debug!(
2019-06-06 20:37:26 -04:00
"Running rust part of compile_sync. module_name: {}",
&module_name
);
2019-06-06 20:37:26 -04:00
let root_names = vec![module_name.clone()];
let compiler_config = get_compiler_config(&state, "typescript");
2019-06-08 14:42:28 -04:00
let req_msg = req(root_names, compiler_config, None);
// Count how many times we start the compiler worker.
state.metrics.compiler_starts.fetch_add(1, Ordering::SeqCst);
let mut worker = Worker::new(
"TS".to_string(),
startup_data::compiler_isolate_init(),
// TODO(ry) Maybe we should use a separate state for the compiler.
// as was done previously.
state.clone(),
);
js_check(worker.execute("denoMain()"));
js_check(worker.execute("workerMain()"));
js_check(worker.execute("compilerMain()"));
2019-06-06 20:37:26 -04:00
let compiling_job = state.progress.add(format!("Compiling {}", module_name));
2019-05-11 10:23:19 -04:00
let resource = worker.state.resource.clone();
let compiler_rid = resource.rid;
let first_msg_fut = resources::post_message_to_worker(compiler_rid, req_msg)
.then(move |_| worker)
.then(move |result| {
if let Err(err) = result {
// TODO(ry) Need to forward the error instead of exiting.
eprintln!("{}", err.to_string());
std::process::exit(1);
}
debug!("Sent message to worker");
let stream_future =
resources::get_message_stream_from_worker(compiler_rid).into_future();
stream_future.map(|(f, _rest)| f).map_err(|(f, _rest)| f)
});
first_msg_fut
.map_err(|_| panic!("not handled"))
.and_then(move |maybe_msg: Option<Buf>| {
debug!("Received message from worker");
if let Some(msg) = maybe_msg {
let json_str = std::str::from_utf8(&msg).unwrap();
debug!("Message: {}", json_str);
if let Some(diagnostics) = Diagnostic::from_emit_result(json_str) {
return Err(diagnostics);
}
}
Ok(())
}).and_then(move |_| {
state.dir.fetch_module_meta_data_async(
&module_name,
".",
true,
true,
).map_err(|e| {
// TODO(95th) Instead of panicking, We could translate this error to Diagnostic.
panic!("{}", e)
})
}).and_then(move |module_meta_data_after_compile| {
// Explicit drop to keep reference alive until future completes.
drop(compiling_job);
2019-05-11 10:23:19 -04:00
Ok(module_meta_data_after_compile)
}).then(move |r| {
// TODO(ry) do this in worker's destructor.
// resource.close();
r
2019-04-05 00:04:06 -04:00
})
}
pub fn compile_sync(
state: ThreadSafeState,
2019-04-05 00:04:06 -04:00
module_meta_data: &ModuleMetaData,
) -> Result<ModuleMetaData, Diagnostic> {
2019-06-06 20:37:26 -04:00
tokio_util::block_on(compile_async(state, module_meta_data))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_compile_sync() {
2019-04-05 00:04:06 -04:00
tokio_util::init(|| {
let specifier = "./tests/002_hello.ts";
use crate::module_specifier::ModuleSpecifier;
let module_name = ModuleSpecifier::resolve_root(specifier)
.unwrap()
.to_string();
2019-04-05 00:04:06 -04:00
let mut out = ModuleMetaData {
module_name,
2019-04-05 00:04:06 -04:00
module_redirect_source_name: None,
filename: "/tests/002_hello.ts".to_owned(),
media_type: msg::MediaType::TypeScript,
source_code: include_bytes!("../tests/002_hello.ts").to_vec(),
maybe_output_code_filename: None,
maybe_output_code: None,
maybe_source_map_filename: None,
maybe_source_map: None,
};
2019-06-08 14:42:28 -04:00
out = compile_sync(
ThreadSafeState::mock(vec![
String::from("./deno"),
String::from("hello.js"),
]),
&out,
).unwrap();
2019-04-05 00:04:06 -04:00
assert!(
out
.maybe_output_code
.unwrap()
.starts_with("console.log(\"Hello World\");".as_bytes())
);
})
}
#[test]
fn test_get_compiler_config_no_flag() {
let compiler_type = "typescript";
2019-06-08 14:42:28 -04:00
let state = ThreadSafeState::mock(vec![
String::from("./deno"),
String::from("hello.js"),
]);
let out = get_compiler_config(&state, compiler_type);
assert_eq!(out, None);
}
2019-06-08 14:42:28 -04:00
#[test]
fn test_bundle_async() {
let specifier = "./tests/002_hello.ts";
use crate::module_specifier::ModuleSpecifier;
let module_name = ModuleSpecifier::resolve_root(specifier)
2019-06-08 14:42:28 -04:00
.unwrap()
.to_string();
let state = ThreadSafeState::mock(vec![
String::from("./deno"),
String::from("./tests/002_hello.ts"),
String::from("$deno$/bundle.js"),
]);
let out =
bundle_async(state, module_name, String::from("$deno$/bundle.js"));
assert_eq!(tokio_util::block_on(out), Ok(()));
}
}