diff --git a/crates/proc-macro-api/src/lib.rs b/crates/proc-macro-api/src/lib.rs index a725b94f04b2..7e823444d19d 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, &'a Option>), > + Clone, ) -> io::Result { - 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 1365245f9846..06d6c98681f4 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, &'a Option>), > + Clone, - protocol: Protocol, ) -> io::Result { - 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, &'a Option>), >, - protocol: &Protocol, ) -> io::Result { - 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, &'a Option>), >, - protocol: &Protocol, ) -> io::Result { #[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 b6c38da45475..813ac339a91d 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::::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 { 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 { 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 029ab6eca941..e4456d2e971e 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_::(), - ProtocolFormat::Postcard => run_::(), + ProtocolFormat::JsonLegacy => run_::(), + ProtocolFormat::PostcardLegacy => run_::(), } }