Call ninja directly from build.rs (#2020)

3 files changed, 148 insertions, 12 deletions

diff --git a/tools/format.py b/tools/format.py
index b0d3bc5e4..8dec2117c 100755
--- a/tools/format.py
+++ b/tools/format.py
@@ -46,4 +46,4 @@ qrun([
     "third_party/rustfmt/" + platform() + "/rustfmt",
     "--config-path",
     rustfmt_config,
-] + find_exts(["cli", "core"], [".rs"]))
+] + find_exts(["cli", "core", "tools"], [".rs"]))
diff --git a/tools/gn.rs b/tools/gn.rs
new file mode 100644
index 000000000..d43399fe9
--- /dev/null
+++ b/tools/gn.rs
@@ -0,0 +1,138 @@
+// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
+// This is used in cli/build.rs and core/build.rs to interface with the GN build
+// system (which defines the deno build).
+
+use std::env;
+use std::path::{self, Path, PathBuf};
+use std::process::Command;
+
+pub struct Build {
+  gn_mode: String,
+  root: PathBuf,
+  pub gn_out_dir: String,
+  pub gn_out_path: PathBuf,
+  pub check_only: bool,
+}
+
+impl Build {
+  pub fn setup() -> Build {
+    let gn_mode = if cfg!(target_os = "windows") {
+      // On Windows, we need to link with a release build of libdeno, because
+      // rust always uses the release CRT.
+      // TODO(piscisaureus): make linking with debug libdeno possible.
+      String::from("release")
+    } else {
+      // Cargo sets PROFILE to either "debug" or "release", which conveniently
+      // matches the build modes we support.
+      env::var("PROFILE").unwrap()
+    };
+
+    // cd into workspace root.
+    assert!(env::set_current_dir("..").is_ok());
+
+    let root = env::current_dir().unwrap();
+    // If not using host default target the output folder will change
+    // target/release will become target/$TARGET/release
+    // Gn should also be using this output directory as well
+    // most things will work with gn using the default
+    // output directory but some tests depend on artifacts
+    // being in a specific directory relative to the main build output
+    let gn_out_path = root.join(format!("target/{}", gn_mode.clone()));
+    let gn_out_dir = normalize_path(&gn_out_path);
+
+    // Tell Cargo when to re-run this file. We do this first, so these directives
+    // can take effect even if something goes wrong later in the build process.
+    println!("cargo:rerun-if-env-changed=DENO_BUILD_PATH");
+    // TODO: this is obviously not appropriate here.
+    println!("cargo:rerun-if-env-changed=APPVEYOR_REPO_COMMIT");
+
+    // This helps Rust source files locate the snapshot, source map etc.
+    println!("cargo:rustc-env=GN_OUT_DIR={}", gn_out_dir);
+
+    // Detect if we're being invoked by the rust language server (RLS).
+    // Unfortunately we can't detect whether we're being run by `cargo check`.
+    let check_only = env::var_os("CARGO")
+      .map(PathBuf::from)
+      .as_ref()
+      .and_then(|p| p.file_stem())
+      .and_then(|f| f.to_str())
+      .map(|s| s.starts_with("rls"))
+      .unwrap_or(false);
+
+    if check_only {
+      // Enable the 'check_only' feature, which enables some workarounds in the
+      // rust source code to compile successfully without a bundle and snapshot
+      println!("cargo:rustc-cfg=feature=\"check-only\"");
+    }
+
+    Build {
+      gn_out_dir,
+      gn_out_path,
+      check_only,
+      gn_mode,
+      root,
+    }
+  }
+
+  pub fn run(&self, gn_target: &str) {
+    if !self.gn_out_path.join("build.ninja").exists() {
+      let status = Command::new("python")
+        .env("DENO_BUILD_PATH", &self.gn_out_dir)
+        .env("DENO_BUILD_MODE", &self.gn_mode)
+        .env("DEPOT_TOOLS_WIN_TOOLCHAIN", "0")
+        .arg("./tools/setup.py")
+        .status()
+        .expect("setup.py failed");
+      assert!(status.success());
+    }
+
+    let mut ninja = Command::new("third_party/depot_tools/ninja");
+    let ninja = if !cfg!(target_os = "windows") {
+      &mut ninja
+    } else {
+      // Windows needs special configuration. This is similar to the function of
+      // python_env() in //tools/util.py.
+      let python_path: Vec<String> = vec![
+        "third_party/python_packages",
+        "third_party/python_packages/win32",
+        "third_party/python_packages/win32/lib",
+        "third_party/python_packages/Pythonwin",
+      ].into_iter()
+      .map(|p| self.root.join(p).into_os_string().into_string().unwrap())
+      .collect();
+      let orig_path = String::from(";")
+        + &env::var_os("PATH").unwrap().into_string().unwrap();
+      let path = self
+        .root
+        .join("third_party/python_packages/pywin32_system32")
+        .into_os_string()
+        .into_string()
+        .unwrap();
+      ninja
+        .env("PYTHONPATH", python_path.join(";"))
+        .env("PATH", path + &orig_path)
+        .env("DEPOT_TOOLS_WIN_TOOLCHAIN", "0")
+    };
+
+    let status = ninja
+      .arg(gn_target)
+      .arg("-C")
+      .arg(&self.gn_out_dir)
+      .status()
+      .expect("ninja failed");
+    assert!(status.success());
+  }
+}
+
+// Utility function to make a path absolute, normalizing it to use forward
+// slashes only. The returned value is an owned String, otherwise panics.
+fn normalize_path<T: AsRef<Path>>(path: T) -> String {
+  path
+    .as_ref()
+    .to_str()
+    .unwrap()
+    .to_owned()
+    .chars()
+    .map(|c| if path::is_separator(c) { '/' } else { c })
+    .collect()
+}
diff --git a/tools/hyper_hello.rs b/tools/hyper_hello.rs
index d46ba3e14..7a24ea735 100644
--- a/tools/hyper_hello.rs
+++ b/tools/hyper_hello.rs
@@ -4,10 +4,10 @@
 #![deny(warnings)]
 extern crate hyper;
 
-use std::env;
-use hyper::{Body, Response, Server};
-use hyper::service::service_fn_ok;
 use hyper::rt::{self, Future};
+use hyper::service::service_fn_ok;
+use hyper::{Body, Response, Server};
+use std::env;
 
 static PHRASE: &'static [u8] = b"Hello World!";
 
@@ -22,17 +22,15 @@ fn main() {
   // new_service is run for each connection, creating a 'service'
   // to handle requests for that specific connection.
   let new_service = || {
-      // This is the `Service` that will handle the connection.
-      // `service_fn_ok` is a helper to convert a function that
-      // returns a Response into a `Service`.
-      service_fn_ok(|_| {
-          Response::new(Body::from(PHRASE))
-      })
+    // This is the `Service` that will handle the connection.
+    // `service_fn_ok` is a helper to convert a function that
+    // returns a Response into a `Service`.
+    service_fn_ok(|_| Response::new(Body::from(PHRASE)))
   };
 
   let server = Server::bind(&addr)
-      .serve(new_service)
-      .map_err(|e| eprintln!("server error: {}", e));
+    .serve(new_service)
+    .map_err(|e| eprintln!("server error: {}", e));
 
   println!("Listening on http://{}", addr);