rust-analyzer

diff --git a/crates/proc-macro-api/src/lib.rs b/crates/proc-macro-api/src/lib.rs
index a725b94f04..7e823444d1 100644
--- a/crates/proc-macro-api/src/lib.rs
+++ b/crates/proc-macro-api/src/lib.rs

@@ -22,7 +22,7 @@ use span::{ErasedFileAstId, FIXUP_ERASED_FILE_AST_ID_MARKER, Span};

use std::{fmt, io, sync::Arc, time::SystemTime};

pub use crate::codec::Codec;

-use crate::{legacy_protocol::SpanMode, process::ProcMacroServerProcess};

+use crate::process::ProcMacroServerProcess;

/// The versions of the server protocol

pub mod version {

@@ -126,11 +126,7 @@ impl ProcMacroClient {

Item = (impl AsRef<std::ffi::OsStr>, &'a Option<impl 'a + AsRef<std::ffi::OsStr>>),

> + Clone,

) -> io::Result<ProcMacroClient> {

- let process = ProcMacroServerProcess::run(

- process_path,

- env,

- process::Protocol::Postcard { mode: SpanMode::Id },

- )?;

+ let process = ProcMacroServerProcess::run(process_path, env)?;

Ok(ProcMacroClient { process: Arc::new(process), path: process_path.to_owned() })

}

diff --git a/crates/proc-macro-api/src/process.rs b/crates/proc-macro-api/src/process.rs
index 1365245f98..06d6c98681 100644
--- a/crates/proc-macro-api/src/process.rs
+++ b/crates/proc-macro-api/src/process.rs

@@ -30,8 +30,13 @@ pub(crate) struct ProcMacroServerProcess {

#[derive(Debug, Clone)]

pub(crate) enum Protocol {

- LegacyJson { mode: SpanMode },

- Postcard { mode: SpanMode },

+ LegacyJson {

+ mode: SpanMode,

+ },

+ #[expect(dead_code)]

+ Postcard {

+ mode: SpanMode,

+ },

}

/// Maintains the state of the proc-macro server process.

@@ -49,82 +54,50 @@ impl ProcMacroServerProcess {

env: impl IntoIterator<

Item = (impl AsRef<std::ffi::OsStr>, &'a Option<impl 'a + AsRef<std::ffi::OsStr>>),

> + Clone,

- protocol: Protocol,

) -> io::Result<ProcMacroServerProcess> {

- let mut srv = {

- let mut process = match Process::run(process_path, env.clone(), &protocol) {

- Ok(process) => process,

- Err(e) => {

- // fallback

- if matches!(protocol, Protocol::Postcard { .. }) {

- // retry with json

- return Self::run(

- process_path,

- env,

- Protocol::LegacyJson { mode: SpanMode::Id },

- );

- }

- return Err(e);

- }

- };

+ let create_srv = || {

+ let mut process = Process::run(process_path, env.clone())?;

let (stdin, stdout) = process.stdio().expect("couldn't access child stdio");

- ProcMacroServerProcess {

+ io::Result::Ok(ProcMacroServerProcess {

state: Mutex::new(ProcessSrvState { process, stdin, stdout }),

version: 0,

- protocol: protocol.clone(),

+ protocol: Protocol::LegacyJson { mode: SpanMode::Id },

exited: OnceLock::new(),

- }

+ })

};

+ let mut srv = create_srv()?;

tracing::info!("sending proc-macro server version check");

- let version = match srv.version_check() {

- Ok(v) => v,

- Err(e) => {

- if matches!(protocol, Protocol::Postcard { .. }) {

- // retry with json

- return Self::run(

- process_path,

- env,

- Protocol::LegacyJson { mode: SpanMode::Id },

- );

+ match srv.version_check() {

+ Ok(v) if v > version::CURRENT_API_VERSION => {

+ #[allow(clippy::disallowed_methods)]

+ let process_version = Command::new(process_path)

+ .arg("--version")

+ .output()

+ .map(|output| String::from_utf8_lossy(&output.stdout).trim().to_owned())

+ .unwrap_or_else(|_| "unknown version".to_owned());

+ Err(io::Error::other(format!(

+ "Your installed proc-macro server is too new for your rust-analyzer. API version: {}, server version: {process_version}. \

+ This will prevent proc-macro expansion from working. Please consider updating your rust-analyzer to ensure compatibility with your current toolchain.",

+ version::CURRENT_API_VERSION

+ )))

+ }

+ Ok(v) => {

+ tracing::info!("Proc-macro server version: {v}");

+ srv.version = v;

+ if srv.version >= version::RUST_ANALYZER_SPAN_SUPPORT

+ && let Ok(mode) = srv.enable_rust_analyzer_spans()

+ {

+ srv.protocol = Protocol::LegacyJson { mode };

}

+ tracing::info!("Proc-macro server protocol: {:?}", srv.protocol);

+ Ok(srv)

+ }

+ Err(e) => {

tracing::info!(%e, "proc-macro version check failed");

- return Err(io::Error::other(format!(

- "proc-macro server version check failed: {e}"

- )));

+ Err(io::Error::other(format!("proc-macro server version check failed: {e}")))

}

- };

- if version > version::CURRENT_API_VERSION {

- #[allow(clippy::disallowed_methods)]

- let process_version = Command::new(process_path)

- .arg("--version")

- .output()

- .map(|out| String::from_utf8_lossy(&out.stdout).trim().to_owned())

- .unwrap_or_else(|_| "unknown version".to_owned());

- return Err(io::Error::other(format!(

- "Your installed proc-macro server is too new for your rust-analyzer. API version: {}, server version: {process_version}. \

- This will prevent proc-macro expansion from working. Please consider updating your rust-analyzer to ensure compatibility with your current toolchain.",

- version::CURRENT_API_VERSION

- )));

- }

- tracing::info!("proc-macro server version: {version}");

- srv.version = version;

- if version >= version::RUST_ANALYZER_SPAN_SUPPORT

- && let Ok(new_mode) = srv.enable_rust_analyzer_spans()

- {

- match &mut srv.protocol {

- Protocol::Postcard { mode } | Protocol::LegacyJson { mode } => *mode = new_mode,

- };

}

- tracing::info!("proc-macro server protocol: {:?}", srv.protocol);

- Ok(srv)

}

/// Returns the server error if the process has exited.

@@ -247,9 +220,8 @@ impl Process {

env: impl IntoIterator<

Item = (impl AsRef<std::ffi::OsStr>, &'a Option<impl 'a + AsRef<std::ffi::OsStr>>),

- protocol: &Protocol,

) -> io::Result<Process> {

- let child = JodChild(mk_child(path, env, protocol)?);

+ let child = JodChild(mk_child(path, env)?);

Ok(Process { child })

}

@@ -269,15 +241,9 @@ fn mk_child<'a>(

extra_env: impl IntoIterator<

Item = (impl AsRef<std::ffi::OsStr>, &'a Option<impl 'a + AsRef<std::ffi::OsStr>>),

- protocol: &Protocol,

) -> io::Result<Child> {

#[allow(clippy::disallowed_methods)]

let mut cmd = Command::new(path);

- if matches!(protocol, Protocol::LegacyJson { .. }) {

- cmd.args(["--format", "json"]);

- } else {

- cmd.args(["--format", "postcard"]);

- }

for env in extra_env {

match env {

(key, Some(val)) => cmd.env(key, val),

diff --git a/crates/proc-macro-srv-cli/src/main.rs b/crates/proc-macro-srv-cli/src/main.rs
index b6c38da454..813ac339a9 100644
--- a/crates/proc-macro-srv-cli/src/main.rs
+++ b/crates/proc-macro-srv-cli/src/main.rs

@@ -31,7 +31,7 @@ fn main() -> std::io::Result<()> {

clap::Arg::new("format")

.long("format")

.action(clap::ArgAction::Set)

- .default_value("json")

+ .default_value("json-legacy")

.value_parser(clap::builder::EnumValueParser::<ProtocolFormat>::new()),

clap::Arg::new("version")

.long("version")

@@ -50,25 +50,27 @@ fn main() -> std::io::Result<()> {

#[derive(Copy, Clone)]

enum ProtocolFormat {

- Json,

- Postcard,

+ JsonLegacy,

+ PostcardLegacy,

}

impl ValueEnum for ProtocolFormat {

fn value_variants<'a>() -> &'a [Self] {

- &[ProtocolFormat::Json, ProtocolFormat::Postcard]

+ &[ProtocolFormat::JsonLegacy, ProtocolFormat::PostcardLegacy]

}

fn to_possible_value(&self) -> Option<clap::builder::PossibleValue> {

match self {

- ProtocolFormat::Json => Some(clap::builder::PossibleValue::new("json")),

- ProtocolFormat::Postcard => Some(clap::builder::PossibleValue::new("postcard")),

+ ProtocolFormat::JsonLegacy => Some(clap::builder::PossibleValue::new("json-legacy")),

+ ProtocolFormat::PostcardLegacy => {

+ Some(clap::builder::PossibleValue::new("postcard-legacy"))

+ }

}

fn from_str(input: &str, _ignore_case: bool) -> Result<Self, String> {

match input {

- "json" => Ok(ProtocolFormat::Json),

- "postcard" => Ok(ProtocolFormat::Postcard),

+ "json-legacy" => Ok(ProtocolFormat::JsonLegacy),

+ "postcard-legacy" => Ok(ProtocolFormat::PostcardLegacy),

_ => Err(format!("unknown protocol format: {input}")),

}

diff --git a/crates/proc-macro-srv-cli/src/main_loop.rs b/crates/proc-macro-srv-cli/src/main_loop.rs
index 029ab6eca9..e4456d2e97 100644
--- a/crates/proc-macro-srv-cli/src/main_loop.rs
+++ b/crates/proc-macro-srv-cli/src/main_loop.rs

@@ -37,8 +37,8 @@ impl SpanTransformer for SpanTrans {

pub(crate) fn run(format: ProtocolFormat) -> io::Result<()> {

match format {

- ProtocolFormat::Json => run_::<JsonProtocol>(),

- ProtocolFormat::Postcard => run_::<PostcardProtocol>(),

+ ProtocolFormat::JsonLegacy => run_::<JsonProtocol>(),

+ ProtocolFormat::PostcardLegacy => run_::<PostcardProtocol>(),

}