Read version of rustc that compiled proc macro

With Jay Somedon <jay.somedon@outlook.com>

Cargo.lock

@@ -80,7 +80,7 @@ dependencies = [
  "cfg-if",
  "libc",
  "miniz_oxide",
- "object",
+ "object 0.23.0",
  "rustc-demangle",
 ]
 
@@ -1008,6 +1008,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "object"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d3b63360ec3cb337817c2dbd47ab4a0f170d285d8e5a2064600f3def1402397"
+dependencies = [
+ "flate2",
+ "wasmparser",
+]
+
 [[package]]
 name = "object"
 version = "0.23.0"
@@ -1154,8 +1164,10 @@ dependencies = [
  "crossbeam-channel",
  "jod-thread",
  "log",
+ "object 0.22.0",
  "serde",
  "serde_json",
+ "snap",
  "stdx",
  "tt",
 ]
@@ -1168,7 +1180,7 @@ dependencies = [
  "libloading",
  "mbe",
  "memmap2",
- "object",
+ "object 0.23.0",
  "proc_macro_api",
  "proc_macro_test",
  "serde_derive",
@@ -1540,6 +1552,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "snap"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc725476a1398f0480d56cd0ad381f6f32acf2642704456f8f59a35df464b59a"
+
 [[package]]
 name = "socket2"
 version = "0.3.19"
@@ -1880,6 +1898,12 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "wasmparser"
+version = "0.57.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32fddd575d477c6e9702484139cf9f23dcd554b06d185ed0f56c857dd3a47aa6"
+
 [[package]]
 name = "winapi"
 version = "0.3.9"

crates/proc_macro_api/Cargo.toml

@@ -19,3 +19,5 @@ jod-thread = "0.1.1"
 tt = { path = "../tt", version = "0.0.0" }
 base_db = { path = "../base_db", version = "0.0.0" }
 stdx = { path = "../stdx", version = "0.0.0" }
+snap = "1"
+object = "0.22.0"

crates/proc_macro_api/src/lib.rs

@@ -5,16 +5,11 @@
 //! is used to provide basic infrastructure for communication between two
 //! processes: Client (RA itself), Server (the external program)
 
-mod rpc;
-mod process;
 pub mod msg;
+mod process;
+mod rpc;
 
-use std::{
+use std::{ffi::OsStr, fs::read as fsread, io::{self, Read}, path::{Path, PathBuf}, sync::Arc};
-    ffi::OsStr,
-    io,
-    path::{Path, PathBuf},
-    sync::Arc,
-};
 
 use base_db::{Env, ProcMacro};
 use tt::{SmolStr, Subtree};
@@ -23,6 +18,9 @@ use crate::process::{ProcMacroProcessSrv, ProcMacroProcessThread};
 
 pub use rpc::{ExpansionResult, ExpansionTask, ListMacrosResult, ListMacrosTask, ProcMacroKind};
 
+use object::read::{File as BinaryFile, Object, ObjectSection};
+use snap::read::FrameDecoder as SnapDecoder;
+
 #[derive(Debug, Clone)]
 struct ProcMacroProcessExpander {
     process: Arc<ProcMacroProcessSrv>,
@@ -71,7 +69,10 @@ impl ProcMacroClient {
         args: impl IntoIterator<Item = impl AsRef<OsStr>>,
     ) -> io::Result<ProcMacroClient> {
         let (thread, process) = ProcMacroProcessSrv::run(process_path, args)?;
-        Ok(ProcMacroClient { process: Arc::new(process), thread })
+        Ok(ProcMacroClient {
+            process: Arc::new(process),
+            thread,
+        })
     }
 
     pub fn by_dylib_path(&self, dylib_path: &Path) -> Vec<ProcMacro> {
@@ -98,8 +99,69 @@ impl ProcMacroClient {
                     dylib_path: dylib_path.into(),
                 });
 
-                ProcMacro { name, kind, expander }
+                ProcMacro {
+                    name,
+                    kind,
+                    expander,
+                }
             })
             .collect()
     }
+
+    // This is used inside self.read_version() to locate the ".rustc" section
+    // from a proc macro crate's binary file.
+    fn read_section<'a>(&self, dylib_binary: &'a [u8], section_name: &str) -> &'a [u8] {
+        BinaryFile::parse(dylib_binary)
+            .unwrap()
+            .section_by_name(section_name)
+            .unwrap()
+            .data()
+            .unwrap()
+    }
+
+    // Check the version of rustc that was used to compile a proc macro crate's
+    // binary file.
+    // A proc macro crate binary's ".rustc" section has following byte layout:
+    // * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes
+    // * ff060000 734e6150 is followed, it's the snappy format magic bytes,
+    //   means bytes from here(including this sequence) are compressed in
+    //   snappy compression format. Version info is here inside, so decompress
+    //   this.
+    // The bytes you get after decompressing the snappy format portion has
+    // following layout:
+    // * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes(again)
+    // * [crate root bytes] next 4 bytes is to store crate root position,
+    //   according to rustc's source code comment
+    // * [length byte] next 1 byte tells us how many bytes we should read next
+    //   for the version string's utf8 bytes
+    // * [version string bytes encoded in utf8] <- GET THIS BOI
+    // * [some more bytes that we don really care but still there] :-)
+    // Check this issue for more about the bytes layout:
+    // https://github.com/rust-analyzer/rust-analyzer/issues/6174
+    fn read_version(&self, dylib_path: &Path) -> String {
+        let dylib_binary = fsread(dylib_path).unwrap();
+
+        let dot_rustc = self.read_section(&dylib_binary, ".rustc");
+
+        let snappy_portion = &dot_rustc[8..];
+
+        let mut snappy_decoder = SnapDecoder::new(snappy_portion);
+
+        // the bytes before version string bytes, so this basically is:
+        // 8 bytes for [b'r',b'u',b's',b't',0,0,0,5]
+        // 4 bytes for [crate root bytes]
+        // 1 byte for length of version string
+        // so 13 bytes in total, and we should check the 13th byte
+        // to know the length
+        let mut bytes_before_version = [0u8; 13];
+        snappy_decoder
+            .read_exact(&mut bytes_before_version)
+            .unwrap();
+        let length = bytes_before_version[12]; // what? can't use -1 indexing?
+
+        let mut version_string_utf8 = vec![0u8; length as usize];
+        snappy_decoder.read_exact(&mut version_string_utf8).unwrap();
+        let version_string = String::from_utf8(version_string_utf8).unwrap();
+        version_string
+    }
 }