2020-06-21 07:58:34 -05:00
|
|
|
use std::{
|
|
|
|
env,
|
|
|
|
fs::File,
|
|
|
|
io,
|
|
|
|
path::{Path, PathBuf},
|
|
|
|
};
|
2020-03-04 11:36:16 -06:00
|
|
|
|
|
|
|
use anyhow::Result;
|
2020-10-16 12:46:03 -05:00
|
|
|
use flate2::{write::GzEncoder, Compression};
|
2021-05-22 12:23:03 -05:00
|
|
|
use xshell::{cmd, mkdir_p, pushd, pushenv, read_file, rm_rf, write_file};
|
2020-03-04 11:36:16 -06:00
|
|
|
|
2021-04-26 07:17:02 -05:00
|
|
|
use crate::{date_iso, flags, project_root};
|
2020-03-04 11:36:16 -06:00
|
|
|
|
2021-04-26 07:17:02 -05:00
|
|
|
impl flags::Dist {
|
2021-03-01 11:16:23 -06:00
|
|
|
pub(crate) fn run(self) -> Result<()> {
|
2021-04-26 07:17:02 -05:00
|
|
|
let stable =
|
|
|
|
std::env::var("GITHUB_REF").unwrap_or_default().as_str() == "refs/heads/release";
|
|
|
|
|
2020-07-24 08:59:01 -05:00
|
|
|
let dist = project_root().join("dist");
|
|
|
|
rm_rf(&dist)?;
|
2020-10-16 12:46:03 -05:00
|
|
|
mkdir_p(&dist)?;
|
2020-07-24 08:59:01 -05:00
|
|
|
|
2021-04-26 07:17:02 -05:00
|
|
|
if let Some(patch_version) = self.client_patch_version {
|
|
|
|
let version = if stable {
|
|
|
|
format!("0.2.{}", patch_version)
|
|
|
|
} else {
|
|
|
|
// A hack to make VS Code prefer nightly over stable.
|
|
|
|
format!("0.3.{}", patch_version)
|
|
|
|
};
|
|
|
|
let release_tag = if stable { date_iso()? } else { "nightly".to_string() };
|
2020-07-24 08:59:01 -05:00
|
|
|
dist_client(&version, &release_tag)?;
|
|
|
|
}
|
2021-04-26 07:17:02 -05:00
|
|
|
let release_channel = if stable { "stable" } else { "nightly" };
|
2021-04-24 05:36:45 -05:00
|
|
|
dist_server(release_channel)?;
|
2020-07-24 08:59:01 -05:00
|
|
|
Ok(())
|
2020-03-04 11:36:16 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-19 03:32:57 -05:00
|
|
|
fn dist_client(version: &str, release_tag: &str) -> Result<()> {
|
2020-10-16 12:46:03 -05:00
|
|
|
let _d = pushd("./editors/code")?;
|
2020-03-19 03:32:57 -05:00
|
|
|
let nightly = release_tag == "nightly";
|
2020-03-04 11:36:16 -06:00
|
|
|
|
2020-03-19 03:32:57 -05:00
|
|
|
let mut patch = Patch::new("./package.json")?;
|
2020-03-04 11:36:16 -06:00
|
|
|
|
2020-03-19 03:32:57 -05:00
|
|
|
patch
|
|
|
|
.replace(r#""version": "0.4.0-dev""#, &format!(r#""version": "{}""#, version))
|
2021-04-23 14:08:09 -05:00
|
|
|
.replace(r#""releaseTag": null"#, &format!(r#""releaseTag": "{}""#, release_tag))
|
2021-06-15 01:32:53 -05:00
|
|
|
.replace(r#""$generated-start": {},"#, "")
|
|
|
|
.replace(",\n \"$generated-end\": {}", "");
|
2020-03-04 11:36:16 -06:00
|
|
|
|
|
|
|
if nightly {
|
2020-03-18 07:23:44 -05:00
|
|
|
patch.replace(
|
2020-03-04 14:35:31 -06:00
|
|
|
r#""displayName": "rust-analyzer""#,
|
2020-03-18 07:23:44 -05:00
|
|
|
r#""displayName": "rust-analyzer (nightly)""#,
|
2020-03-04 14:35:31 -06:00
|
|
|
);
|
2020-03-04 11:36:16 -06:00
|
|
|
}
|
2020-03-18 07:23:44 -05:00
|
|
|
if !nightly {
|
|
|
|
patch.replace(r#""enableProposedApi": true,"#, r#""#);
|
|
|
|
}
|
|
|
|
patch.commit()?;
|
2020-03-04 11:36:16 -06:00
|
|
|
|
2020-10-16 12:46:03 -05:00
|
|
|
cmd!("npm ci").run()?;
|
|
|
|
cmd!("npx vsce package -o ../../dist/rust-analyzer.vsix").run()?;
|
2020-03-04 11:36:16 -06:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2021-04-24 05:36:45 -05:00
|
|
|
fn dist_server(release_channel: &str) -> Result<()> {
|
|
|
|
let _e = pushenv("RUST_ANALYZER_CHANNEL", release_channel);
|
2021-05-24 06:41:31 -05:00
|
|
|
let _e = pushenv("CARGO_PROFILE_RELEASE_LTO", "thin");
|
2021-05-27 03:53:33 -05:00
|
|
|
|
|
|
|
// Uncomment to enable debug info for releases. Note that:
|
|
|
|
// * debug info is split on windows and macs, so it does nothing for those platforms,
|
|
|
|
// * on Linux, this blows up the binary size from 8MB to 43MB, which is unreasonable.
|
|
|
|
// let _e = pushenv("CARGO_PROFILE_RELEASE_DEBUG", "1");
|
2021-05-23 06:06:25 -05:00
|
|
|
|
2020-12-21 13:06:46 -06:00
|
|
|
let target = get_target();
|
2021-02-13 02:39:02 -06:00
|
|
|
if target.contains("-linux-gnu") || target.contains("-linux-musl") {
|
2020-06-21 07:58:34 -05:00
|
|
|
env::set_var("CC", "clang");
|
2020-03-04 11:36:16 -06:00
|
|
|
}
|
|
|
|
|
2021-01-02 01:51:41 -06:00
|
|
|
cmd!("cargo build --manifest-path ./crates/rust-analyzer/Cargo.toml --bin rust-analyzer --target {target} --release").run()?;
|
2020-06-21 07:58:34 -05:00
|
|
|
|
2020-12-21 13:06:46 -06:00
|
|
|
let suffix = exe_suffix(&target);
|
|
|
|
let src =
|
|
|
|
Path::new("target").join(&target).join("release").join(format!("rust-analyzer{}", suffix));
|
|
|
|
let dst = Path::new("dist").join(format!("rust-analyzer-{}{}", target, suffix));
|
2020-06-21 07:58:34 -05:00
|
|
|
gzip(&src, &dst.with_extension("gz"))?;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
2020-03-04 11:36:16 -06:00
|
|
|
|
2020-12-21 13:06:46 -06:00
|
|
|
fn get_target() -> String {
|
|
|
|
match env::var("RA_TARGET") {
|
|
|
|
Ok(target) => target,
|
|
|
|
_ => {
|
|
|
|
if cfg!(target_os = "linux") {
|
|
|
|
"x86_64-unknown-linux-gnu".to_string()
|
|
|
|
} else if cfg!(target_os = "windows") {
|
|
|
|
"x86_64-pc-windows-msvc".to_string()
|
|
|
|
} else if cfg!(target_os = "macos") {
|
|
|
|
"x86_64-apple-darwin".to_string()
|
|
|
|
} else {
|
|
|
|
panic!("Unsupported OS, maybe try setting RA_TARGET")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn exe_suffix(target: &str) -> String {
|
|
|
|
if target.contains("-windows-") {
|
|
|
|
".exe".into()
|
|
|
|
} else {
|
|
|
|
"".into()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-21 07:58:34 -05:00
|
|
|
fn gzip(src_path: &Path, dest_path: &Path) -> Result<()> {
|
|
|
|
let mut encoder = GzEncoder::new(File::create(dest_path)?, Compression::best());
|
|
|
|
let mut input = io::BufReader::new(File::open(src_path)?);
|
|
|
|
io::copy(&mut input, &mut encoder)?;
|
|
|
|
encoder.finish()?;
|
2020-03-04 11:36:16 -06:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2020-03-18 07:23:44 -05:00
|
|
|
struct Patch {
|
2020-03-04 11:36:16 -06:00
|
|
|
path: PathBuf,
|
2020-03-18 07:23:44 -05:00
|
|
|
original_contents: String,
|
2020-03-04 11:36:16 -06:00
|
|
|
contents: String,
|
|
|
|
}
|
|
|
|
|
2020-03-18 07:23:44 -05:00
|
|
|
impl Patch {
|
2020-03-19 03:32:57 -05:00
|
|
|
fn new(path: impl Into<PathBuf>) -> Result<Patch> {
|
|
|
|
let path = path.into();
|
2020-10-16 12:46:03 -05:00
|
|
|
let contents = read_file(&path)?;
|
2020-03-18 07:23:44 -05:00
|
|
|
Ok(Patch { path, original_contents: contents.clone(), contents })
|
|
|
|
}
|
|
|
|
|
|
|
|
fn replace(&mut self, from: &str, to: &str) -> &mut Patch {
|
|
|
|
assert!(self.contents.contains(from));
|
|
|
|
self.contents = self.contents.replace(from, to);
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2020-10-16 12:46:03 -05:00
|
|
|
fn commit(&self) -> Result<()> {
|
|
|
|
write_file(&self.path, &self.contents)?;
|
|
|
|
Ok(())
|
2020-03-18 07:23:44 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Drop for Patch {
|
2020-03-04 11:36:16 -06:00
|
|
|
fn drop(&mut self) {
|
2020-10-16 12:46:03 -05:00
|
|
|
write_file(&self.path, &self.original_contents).unwrap();
|
2020-03-04 11:36:16 -06:00
|
|
|
}
|
|
|
|
}
|