7 files changed, 198 insertions, 151 deletions

diff --git a/xtask/src/dist.rs b/xtask/src/dist.rs
index f2503f807..b6aa2f52a 100644
--- a/xtask/src/dist.rs
+++ b/xtask/src/dist.rs
@@ -7,26 +7,31 @@ use std::{
 
 use anyhow::Result;
 use flate2::{write::GzEncoder, Compression};
-use xshell::{cmd, cp, mkdir_p, pushd, read_file, rm_rf, write_file};
+use xshell::{cmd, cp, mkdir_p, pushd, pushenv, read_file, rm_rf, write_file};
 
-use crate::{date_iso, project_root};
+use crate::{date_iso, flags, project_root};
 
-pub(crate) struct DistCmd {
-    pub(crate) nightly: bool,
-    pub(crate) client_version: Option<String>,
-}
-
-impl DistCmd {
+impl flags::Dist {
     pub(crate) fn run(self) -> Result<()> {
+        let stable =
+            std::env::var("GITHUB_REF").unwrap_or_default().as_str() == "refs/heads/release";
+
         let dist = project_root().join("dist");
         rm_rf(&dist)?;
         mkdir_p(&dist)?;
 
-        if let Some(version) = self.client_version {
-            let release_tag = if self.nightly { "nightly".to_string() } else { date_iso()? };
+        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() };
             dist_client(&version, &release_tag)?;
         }
-        dist_server()?;
+        let release_channel = if stable { "stable" } else { "nightly" };
+        dist_server(release_channel)?;
         Ok(())
     }
 }
@@ -39,7 +44,9 @@ fn dist_client(version: &str, release_tag: &str) -> Result<()> {
 
     patch
         .replace(r#""version": "0.4.0-dev""#, &format!(r#""version": "{}""#, version))
-        .replace(r#""releaseTag": null"#, &format!(r#""releaseTag": "{}""#, release_tag));
+        .replace(r#""releaseTag": null"#, &format!(r#""releaseTag": "{}""#, release_tag))
+        .replace(r#""$generated-start": false,"#, "")
+        .replace(",\n                \"$generated-end\": false", "");
 
     if nightly {
         patch.replace(
@@ -57,7 +64,9 @@ fn dist_client(version: &str, release_tag: &str) -> Result<()> {
     Ok(())
 }
 
-fn dist_server() -> Result<()> {
+fn dist_server(release_channel: &str) -> Result<()> {
+    let _e = pushenv("RUST_ANALYZER_CHANNEL", release_channel);
+    let _e = pushenv("CARGO_PROFILE_RELEASE_LTO", "true");
     let target = get_target();
     if target.contains("-linux-gnu") || target.contains("-linux-musl") {
         env::set_var("CC", "clang");
diff --git a/xtask/src/flags.rs b/xtask/src/flags.rs
index 4cd2b1ddb..69b3cb9c1 100644
--- a/xtask/src/flags.rs
+++ b/xtask/src/flags.rs
@@ -28,7 +28,6 @@ xflags::xflags! {
         }
 
         cmd fuzz-tests {}
-        cmd pre-cache {}
 
         cmd release {
             optional --dry-run
@@ -37,8 +36,7 @@ xflags::xflags! {
             optional --dry-run
         }
         cmd dist {
-            optional --nightly
-            optional --client version: String
+            optional --client-patch-version version: String
         }
         cmd metrics {
             optional --dry-run
@@ -63,7 +61,6 @@ pub enum XtaskCmd {
     Help(Help),
     Install(Install),
     FuzzTests(FuzzTests),
-    PreCache(PreCache),
     Release(Release),
     Promote(Promote),
     Dist(Dist),
@@ -86,15 +83,9 @@ pub struct Install {
 }
 
 #[derive(Debug)]
-pub struct Lint;
-
-#[derive(Debug)]
 pub struct FuzzTests;
 
 #[derive(Debug)]
-pub struct PreCache;
-
-#[derive(Debug)]
 pub struct Release {
     pub dry_run: bool,
 }
@@ -106,8 +97,7 @@ pub struct Promote {
 
 #[derive(Debug)]
 pub struct Dist {
-    pub nightly: bool,
-    pub client: Option<String>,
+    pub client_patch_version: Option<String>,
 }
 
 #[derive(Debug)]
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index 960927fc0..d0bef7b7a 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -18,7 +18,6 @@ mod install;
 mod release;
 mod dist;
 mod metrics;
-mod pre_cache;
 
 use anyhow::{bail, Result};
 use std::{
@@ -28,8 +27,6 @@ use std::{
 use walkdir::{DirEntry, WalkDir};
 use xshell::{cmd, cp, pushd, pushenv};
 
-use crate::dist::DistCmd;
-
 fn main() -> Result<()> {
     let _d = pushd(project_root())?;
 
@@ -41,12 +38,9 @@ fn main() -> Result<()> {
         }
         flags::XtaskCmd::Install(cmd) => cmd.run(),
         flags::XtaskCmd::FuzzTests(_) => run_fuzzer(),
-        flags::XtaskCmd::PreCache(cmd) => cmd.run(),
         flags::XtaskCmd::Release(cmd) => cmd.run(),
         flags::XtaskCmd::Promote(cmd) => cmd.run(),
-        flags::XtaskCmd::Dist(flags) => {
-            DistCmd { nightly: flags.nightly, client_version: flags.client }.run()
-        }
+        flags::XtaskCmd::Dist(cmd) => cmd.run(),
         flags::XtaskCmd::Metrics(cmd) => cmd.run(),
         flags::XtaskCmd::Bb(cmd) => {
             {
@@ -112,7 +106,7 @@ fn run_fuzzer() -> Result<()> {
 }
 
 fn date_iso() -> Result<String> {
-    let res = cmd!("date --iso --utc").read()?;
+    let res = cmd!("date -u +%Y-%m-%d").read()?;
     Ok(res)
 }
 
diff --git a/xtask/src/pre_cache.rs b/xtask/src/pre_cache.rs
deleted file mode 100644
index b456224fd..000000000
--- a/xtask/src/pre_cache.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-use std::{
-    fs::FileType,
-    path::{Path, PathBuf},
-};
-
-use anyhow::Result;
-use xshell::rm_rf;
-
-use crate::flags;
-
-impl flags::PreCache {
-    /// Cleans the `./target` dir after the build such that only
-    /// dependencies are cached on CI.
-    pub(crate) fn run(self) -> Result<()> {
-        let slow_tests_cookie = Path::new("./target/.slow_tests_cookie");
-        if !slow_tests_cookie.exists() {
-            panic!("slow tests were skipped on CI!")
-        }
-        rm_rf(slow_tests_cookie)?;
-
-        for path in read_dir("./target/debug", FileType::is_file)? {
-            // Can't delete yourself on windows :-(
-            if !path.ends_with("xtask.exe") {
-                rm_rf(&path)?
-            }
-        }
-
-        rm_rf("./target/.rustc_info.json")?;
-
-        let to_delete = read_dir("./crates", FileType::is_dir)?
-            .into_iter()
-            .map(|path| path.file_name().unwrap().to_string_lossy().replace('-', "_"))
-            .collect::<Vec<_>>();
-
-        for &dir in ["./target/debug/deps", "target/debug/.fingerprint"].iter() {
-            for path in read_dir(dir, |_file_type| true)? {
-                if path.ends_with("xtask.exe") {
-                    continue;
-                }
-                let file_name = path.file_name().unwrap().to_string_lossy();
-                let (stem, _) = match rsplit_once(&file_name, '-') {
-                    Some(it) => it,
-                    None => {
-                        rm_rf(path)?;
-                        continue;
-                    }
-                };
-                let stem = stem.replace('-', "_");
-                if to_delete.contains(&stem) {
-                    rm_rf(path)?;
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-fn read_dir(path: impl AsRef<Path>, cond: impl Fn(&FileType) -> bool) -> Result<Vec<PathBuf>> {
-    read_dir_impl(path.as_ref(), &cond)
-}
-
-fn read_dir_impl(path: &Path, cond: &dyn Fn(&FileType) -> bool) -> Result<Vec<PathBuf>> {
-    let mut res = Vec::new();
-    for entry in path.read_dir()? {
-        let entry = entry?;
-        let file_type = entry.file_type()?;
-        if cond(&file_type) {
-            res.push(entry.path())
-        }
-    }
-    Ok(res)
-}
-
-fn rsplit_once(haystack: &str, delim: char) -> Option<(&str, &str)> {
-    let mut split = haystack.rsplitn(2, delim);
-    let suffix = split.next()?;
-    let prefix = split.next()?;
-    Some((prefix, suffix))
-}
diff --git a/xtask/src/release.rs b/xtask/src/release.rs
index dde5d14ee..452f351d0 100644
--- a/xtask/src/release.rs
+++ b/xtask/src/release.rs
@@ -1,4 +1,4 @@
-use std::fmt::Write;
+mod changelog;
 
 use xshell::{cmd, cp, pushd, read_dir, write_file};
 
@@ -10,7 +10,16 @@ impl flags::Release {
             cmd!("git switch release").run()?;
             cmd!("git fetch upstream --tags --force").run()?;
             cmd!("git reset --hard tags/nightly").run()?;
-            cmd!("git push").run()?;
+            // The `release` branch sometimes has a couple of cherry-picked
+            // commits for patch releases. If that's the case, just overwrite
+            // it. As we are setting `release` branch to an up-to-date `nightly`
+            // tag, this shouldn't be problematic in general.
+            //
+            // Note that, as we tag releases, we don't worry about "losing"
+            // commits -- they'll be kept alive by the tag. More generally, we
+            // don't care about historic releases all that much, it's fine even
+            // to delete old tags.
+            cmd!("git push --force").run()?;
         }
         codegen::docs()?;
 
@@ -38,42 +47,7 @@ impl flags::Release {
         let tags = cmd!("git tag --list").read()?;
         let prev_tag = tags.lines().filter(|line| is_release_tag(line)).last().unwrap();
 
-        let git_log = cmd!("git log {prev_tag}..HEAD --merges --reverse").read()?;
-        let mut git_log_summary = String::new();
-        for line in git_log.lines() {
-            let line = line.trim_start();
-            if let Some(p) = line.find(':') {
-                if let Ok(pr) = line[..p].parse::<u32>() {
-                    writeln!(git_log_summary, "* pr:{}[]{}", pr, &line[p + 1..]).unwrap();
-                }
-            }
-        }
-
-        let contents = format!(
-            "\
-= Changelog #{}
-:sectanchors:
-:page-layout: post
-
-Commit: commit:{}[] +
-Release: release:{}[]
-
-== Sponsors
-
-**Become a sponsor:** On https://opencollective.com/rust-analyzer/[OpenCollective] or
-https://github.com/sponsors/rust-analyzer[GitHub Sponsors].
-
-== New Features
-
-{}
-
-== Fixes
-
-== Internal Improvements
-",
-            changelog_n, commit, today, git_log_summary
-        );
-
+        let contents = changelog::get_changelog(changelog_n, &commit, prev_tag, &today)?;
         let path = changelog_dir.join(format!("{}-changelog-{}.adoc", today, changelog_n));
         write_file(&path, &contents)?;
 
diff --git a/xtask/src/release/changelog.rs b/xtask/src/release/changelog.rs
new file mode 100644
index 000000000..ffcae2cf7
--- /dev/null
+++ b/xtask/src/release/changelog.rs
@@ -0,0 +1,159 @@
+use std::fmt::Write;
+use std::{env, iter};
+
+use anyhow::{bail, Result};
+use xshell::cmd;
+
+pub(crate) fn get_changelog(
+    changelog_n: usize,
+    commit: &str,
+    prev_tag: &str,
+    today: &str,
+) -> Result<String> {
+    let git_log = cmd!("git log {prev_tag}..HEAD --merges --reverse").read()?;
+    let mut features = String::new();
+    let mut fixes = String::new();
+    let mut internal = String::new();
+    let mut others = String::new();
+    for line in git_log.lines() {
+        let line = line.trim_start();
+        if let Some(p) = line.find(':') {
+            let pr = &line[..p];
+            if let Ok(pr_num) = pr.parse::<u32>() {
+                let accept = "Accept: application/vnd.github.v3+json";
+                let token = match env::var("GITHUB_TOKEN") {
+                    Ok(token) => token,
+                    Err(_) => bail!("Please obtain a personal access token from https://github.com/settings/tokens and set the `GITHUB_TOKEN` environment variable."),
+                };
+                let authorization = format!("Authorization: token {}", token);
+                let pr_url = "https://api.github.com/repos/rust-analyzer/rust-analyzer/issues";
+
+                // we don't use an HTTPS client or JSON parser to keep the build times low
+                let pr_json =
+                    cmd!("curl -s -H {accept} -H {authorization} {pr_url}/{pr}").read()?;
+                let pr_title = cmd!("jq .title").stdin(&pr_json).read()?;
+                let pr_title = unescape(&pr_title[1..pr_title.len() - 1]);
+                let pr_comment = cmd!("jq .body").stdin(pr_json).read()?;
+
+                let comments_json =
+                    cmd!("curl -s -H {accept} -H {authorization} {pr_url}/{pr}/comments").read()?;
+                let pr_comments = cmd!("jq .[].body").stdin(comments_json).read()?;
+
+                let l = iter::once(pr_comment.as_str())
+                    .chain(pr_comments.lines())
+                    .rev()
+                    .find_map(|it| {
+                        let it = unescape(&it[1..it.len() - 1]);
+                        it.lines().find_map(parse_changelog_line)
+                    })
+                    .into_iter()
+                    .next()
+                    .unwrap_or_else(|| parse_title_line(&pr_title));
+                let s = match l.kind {
+                    PrKind::Feature => &mut features,
+                    PrKind::Fix => &mut fixes,
+                    PrKind::Internal => &mut internal,
+                    PrKind::Other => &mut others,
+                    PrKind::Skip => continue,
+                };
+                writeln!(s, "* pr:{}[] {}", pr_num, l.message.as_deref().unwrap_or(&pr_title))
+                    .unwrap();
+            }
+        }
+    }
+
+    let contents = format!(
+        "\
+= Changelog #{}
+:sectanchors:
+:page-layout: post
+
+Commit: commit:{}[] +
+Release: release:{}[]
+
+== Sponsors
+
+**Become a sponsor:** On https://opencollective.com/rust-analyzer/[OpenCollective] or
+https://github.com/sponsors/rust-analyzer[GitHub Sponsors].
+
+== New Features
+
+{}
+
+== Fixes
+
+{}
+
+== Internal Improvements
+
+{}
+
+== Others
+
+{}
+",
+        changelog_n, commit, today, features, fixes, internal, others
+    );
+    Ok(contents)
+}
+
+#[derive(Clone, Copy)]
+enum PrKind {
+    Feature,
+    Fix,
+    Internal,
+    Other,
+    Skip,
+}
+
+struct PrInfo {
+    message: Option<String>,
+    kind: PrKind,
+}
+
+fn unescape(s: &str) -> String {
+    s.replace(r#"\""#, "").replace(r#"\n"#, "\n").replace(r#"\r"#, "")
+}
+
+fn parse_changelog_line(s: &str) -> Option<PrInfo> {
+    let parts = s.splitn(3, ' ').collect::<Vec<_>>();
+    if parts.len() < 2 || parts[0] != "changelog" {
+        return None;
+    }
+    let message = parts.get(2).map(|it| it.to_string());
+    let kind = match parts[1].trim_end_matches(':') {
+        "feature" => PrKind::Feature,
+        "fix" => PrKind::Fix,
+        "internal" => PrKind::Internal,
+        "skip" => PrKind::Skip,
+        _ => {
+            let kind = PrKind::Other;
+            let message = format!("{} {}", parts[1], message.unwrap_or_default());
+            return Some(PrInfo { kind, message: Some(message) });
+        }
+    };
+    let res = PrInfo { kind, message };
+    Some(res)
+}
+
+fn parse_title_line(s: &str) -> PrInfo {
+    let lower = s.to_ascii_lowercase();
+    const PREFIXES: [(&str, PrKind); 5] = [
+        ("feat: ", PrKind::Feature),
+        ("feature: ", PrKind::Feature),
+        ("fix: ", PrKind::Fix),
+        ("internal: ", PrKind::Internal),
+        ("minor: ", PrKind::Skip),
+    ];
+
+    for &(prefix, kind) in &PREFIXES {
+        if lower.starts_with(prefix) {
+            let message = match &kind {
+                PrKind::Skip => None,
+                _ => Some(s[prefix.len()..].to_string()),
+            };
+            return PrInfo { kind, message };
+        }
+    }
+    PrInfo { kind: PrKind::Other, message: Some(s.to_string()) }
+}
diff --git a/xtask/src/tidy.rs b/xtask/src/tidy.rs
index 50d9efccd..c3c785eff 100644
--- a/xtask/src/tidy.rs
+++ b/xtask/src/tidy.rs
@@ -224,7 +224,7 @@ Apache-2.0 OR BSL-1.0
 Apache-2.0 OR MIT
 Apache-2.0/MIT
 BSD-3-Clause
-CC0-1.0
+CC0-1.0 OR Artistic-2.0
 ISC
 MIT
 MIT / Apache-2.0