feat: able to choose between two protocols

Author: DriedYellowPeach

crates/proc-macro-api/src/process.rs

@@ -143,11 +143,38 @@ impl ProcMacroServerProcess {
         }
 
         let state = &mut *self.state.lock().unwrap();
-        let mut buf = String::new();
-        let mut client =
-            JsonTaskClient { writer: &mut state.stdin, reader: &mut state.stdout, buf: &mut buf };
+        
+        // Check environment variable to determine which protocol to use
+        let protocol = std::env::var("RUST_ANALYZER_PROC_MACRO_PROTOCOL")
+            .unwrap_or_else(|_| "json".to_string());
+        
+        let result = match protocol.as_str() {
+            "postcard" => {
+                // For now, still use JSON even when postcard is requested
+                // TODO: Implement full postcard protocol support
+                tracing::warn!("Postcard protocol requested but not fully implemented, using JSON");
+                
+                let mut buf = String::new();
+                let mut client = JsonTaskClient { 
+                    writer: &mut state.stdin, 
+                    reader: &mut state.stdout, 
+                    buf: &mut buf 
+                };
+                client.send_task(req)
+            }
+            _ => {
+                // Default to JSON protocol
+                let mut buf = String::new();
+                let mut client = JsonTaskClient { 
+                    writer: &mut state.stdin, 
+                    reader: &mut state.stdout, 
+                    buf: &mut buf 
+                };
+                client.send_task(req)
+            }
+        };
 
-        client.send_task(req).map_err(|e| {
+        result.map_err(|e| {
             if e.io.as_ref().map(|it| it.kind()) == Some(io::ErrorKind::BrokenPipe) {
                 match state.process.child.try_wait() {
                     Ok(None) | Err(_) => e,
@@ -214,6 +241,26 @@ fn mk_child<'a>(
 ) -> io::Result<Child> {
     #[allow(clippy::disallowed_methods)]
     let mut cmd = Command::new(path);
+    
+    // Check for protocol selection environment variable
+    if let Ok(protocol) = std::env::var("RUST_ANALYZER_PROC_MACRO_PROTOCOL") {
+        match protocol.as_str() {
+            "postcard" => {
+                cmd.args(["--format", "postcard"]);
+            }
+            "json" => {
+                cmd.args(["--format", "json"]);
+            }
+            _ => {
+                tracing::warn!("Unknown protocol '{}', defaulting to json", protocol);
+                cmd.args(["--format", "json"]);
+            }
+        }
+    } else {
+        // Default to JSON protocol for backward compatibility
+        cmd.args(["--format", "json"]);
+    }
+    
     for env in extra_env {
         match env {
             (key, Some(val)) => cmd.env(key, val),

crates/proc-macro-srv-cli/src/main_loop.rs

@@ -1,10 +1,42 @@
 //! The main loop of the proc-macro server.
 use std::io;
 
-use crate::task_executor::{TaskExecutor, json_task_executor::JsonTaskExecutor};
+use crate::task_executor::{
+    TaskExecutor, 
+    json_task_executor::JsonTaskExecutor,
+    postcard_task_executor::PostcardTaskExecutor,
+};
 
 pub(crate) fn run() -> io::Result<()> {
-    // Use JsonTaskExecutor for legacy protocol support
-    let executor = JsonTaskExecutor;
-    executor.run()
+    // Check environment variable or command line args to determine protocol
+    let args: Vec<String> = std::env::args().collect();
+    let mut format = None;
+    
+    // Parse --format argument
+    for i in 1..args.len() {
+        if args[i] == "--format" && i + 1 < args.len() {
+            format = Some(args[i + 1].as_str());
+            break;
+        }
+    }
+    
+    // Default to JSON for backward compatibility
+    let protocol = format.unwrap_or("json");
+    
+    match protocol {
+        "json" => {
+            let executor = JsonTaskExecutor;
+            executor.run()
+        }
+        "postcard" => {
+            let executor = PostcardTaskExecutor;
+            executor.run()
+        }
+        _ => {
+            Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                format!("Unsupported protocol format: {}. Supported formats: json, postcard", protocol)
+            ))
+        }
+    }
 }