Merge #6822

6822: Read version of rustc that compiled proc macro r=edwin0cheng a=jsomedon

Signed-off-by: Jay Somedon <[email protected]>

This PR is to fix #6174.

I basically
* added two methods, `read_version` and `read_section`(used by `read_version`)
* two new crates `snap` and `object` to be used by those two methods

I just noticed that some part of code were auto-reformatted by rust-analyzer on file save. Does it matter?

Co-authored-by: Jay Somedon <[email protected]>
Co-authored-by: Edwin Cheng <[email protected]>

4 files changed, 173 insertions, 3 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 51a07abe3..87cf1bf27 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -897,6 +897,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"
 
 [[package]]
+name = "memmap"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6585fd95e7bb50d6cc31e20d4cf9afb4e2ba16c5846fc76793f11218da9c475b"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
 name = "memmap2"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1159,8 +1169,11 @@ dependencies = [
  "crossbeam-channel",
  "jod-thread",
  "log",
+ "memmap",
+ "object",
  "serde",
  "serde_json",
+ "snap",
  "stdx",
  "tt",
 ]
@@ -1546,6 +1559,12 @@ dependencies = [
 ]
 
 [[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"
 source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/crates/proc_macro_api/Cargo.toml b/crates/proc_macro_api/Cargo.toml
index f09726223..16fd56c7e 100644
--- a/crates/proc_macro_api/Cargo.toml
+++ b/crates/proc_macro_api/Cargo.toml
@@ -19,3 +19,6 @@ 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 = { version = "0.23.0", default-features = false, features = ["std", "read_core", "elf", "macho", "pe", "unaligned"] }
+memmap = "0.7.0"
diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs
index 2ea456fb0..941d0fe9e 100644
--- a/crates/proc_macro_api/src/lib.rs
+++ b/crates/proc_macro_api/src/lib.rs
@@ -5,10 +5,12 @@
 //! 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;
+mod version;
 
+use base_db::{Env, ProcMacro};
 use std::{
     ffi::OsStr,
     io,
@@ -16,7 +18,6 @@ use std::{
     sync::Arc,
 };
 
-use base_db::{Env, ProcMacro};
 use tt::{SmolStr, Subtree};
 
 use crate::process::{ProcMacroProcessSrv, ProcMacroProcessThread};
@@ -75,6 +76,21 @@ impl ProcMacroClient {
     }
 
     pub fn by_dylib_path(&self, dylib_path: &Path) -> Vec<ProcMacro> {
+        match version::read_info(dylib_path) {
+            Ok(info) => {
+                if info.version.0 < 1 || info.version.1 < 47 {
+                    eprintln!("proc-macro {} built by {:#?} is not supported by Rust Analyzer, please update your rust version.", dylib_path.to_string_lossy(), info);
+                }
+            }
+            Err(err) => {
+                eprintln!(
+                    "proc-macro {} failed to find the given version. Reason: {}",
+                    dylib_path.to_string_lossy(),
+                    err
+                );
+            }
+        }
+
         let macros = match self.process.find_proc_macros(dylib_path) {
             Err(err) => {
                 eprintln!("Failed to find proc macros. Error: {:#?}", err);
diff --git a/crates/proc_macro_api/src/version.rs b/crates/proc_macro_api/src/version.rs
new file mode 100644
index 000000000..11a7fb59a
--- /dev/null
+++ b/crates/proc_macro_api/src/version.rs
@@ -0,0 +1,132 @@
+//! Reading proc-macro rustc version information from binary data
+
+use std::{
+    fs::File,
+    io::{self, Read},
+    path::Path,
+};
+
+use memmap::Mmap;
+use object::read::{File as BinaryFile, Object, ObjectSection};
+use snap::read::FrameDecoder as SnapDecoder;
+
+#[derive(Debug)]
+pub(crate) struct RustCInfo {
+    pub(crate) version: (usize, usize, usize),
+    pub(crate) channel: String,
+    pub(crate) commit: String,
+    pub(crate) date: String,
+}
+
+pub(crate) fn read_info(dylib_path: &Path) -> io::Result<RustCInfo> {
+    macro_rules! err {
+        ($e:literal) => {
+            io::Error::new(io::ErrorKind::InvalidData, $e)
+        };
+    }
+
+    let ver_str = read_version(dylib_path)?;
+    let mut items = ver_str.split_whitespace();
+    let tag = items.next().ok_or(err!("version format error"))?;
+    if tag != "rustc" {
+        return Err(err!("version format error (No rustc tag)"));
+    }
+
+    let version_part = items.next().ok_or(err!("no version string"))?;
+    let mut version_parts = version_part.split("-");
+    let version = version_parts.next().ok_or(err!("no version"))?;
+    let channel = version_parts.next().unwrap_or_default().to_string();
+
+    let commit = items.next().ok_or(err!("no commit info"))?;
+    // remove (
+    if commit.len() == 0 {
+        return Err(err!("commit format error"));
+    }
+    let commit = commit[1..].to_string();
+    let date = items.next().ok_or(err!("no date info"))?;
+    // remove )
+    if date.len() == 0 {
+        return Err(err!("date format error"));
+    }
+    let date = date[0..date.len() - 2].to_string();
+
+    let version_numbers = version
+        .split(".")
+        .map(|it| it.parse::<usize>())
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|_| err!("version number error"))?;
+
+    if version_numbers.len() != 3 {
+        return Err(err!("version number format error"));
+    }
+    let version = (version_numbers[0], version_numbers[1], version_numbers[2]);
+
+    Ok(RustCInfo { version, channel, commit, date })
+}
+
+/// This is used inside read_version() to locate the ".rustc" section
+/// from a proc macro crate's binary file.
+fn read_section<'a>(dylib_binary: &'a [u8], section_name: &str) -> io::Result<&'a [u8]> {
+    BinaryFile::parse(dylib_binary)
+        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?
+        .section_by_name(section_name)
+        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "section read error"))?
+        .data()
+        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+}
+
+/// 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 inside here, 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(dylib_path: &Path) -> io::Result<String> {
+    let dylib_file = File::open(dylib_path)?;
+    let dylib_mmaped = unsafe { Mmap::map(&dylib_file) }?;
+
+    let dot_rustc = read_section(&dylib_mmaped, ".rustc")?;
+
+    let header = &dot_rustc[..8];
+    const EXPECTED_HEADER: [u8; 8] = [b'r', b'u', b's', b't', 0, 0, 0, 5];
+    // check if header is valid
+    if header != EXPECTED_HEADER {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidData,
+            format!("only metadata version 5 is supported, section header was: {:?}", header),
+        ));
+    }
+
+    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)?;
+    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)?;
+    let version_string = String::from_utf8(version_string_utf8);
+    version_string.map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+}