From 6608acef719ea201d8d6ce9df7d8907aa770c959 Mon Sep 17 00:00:00 2001
From: Jay Somedon <jay.somedon@outlook.com>
Date: Fri, 11 Dec 2020 22:14:42 +0800
Subject: [PATCH 1/8] Read version of rustc that compiled proc macro
With Jay Somedon <jay.somedon@outlook.com>
---
Cargo.lock | 28 ++++++++++-
crates/proc_macro_api/Cargo.toml | 2 +
crates/proc_macro_api/src/lib.rs | 82 ++++++++++++++++++++++++++++----
3 files changed, 100 insertions(+), 12 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 799127891f3..b61fd2e9812 100644
--- a/Cargo.lock
+++ b/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"
diff --git a/crates/proc_macro_api/Cargo.toml b/crates/proc_macro_api/Cargo.toml
index f0972622303..a72ae236af9 100644
--- a/crates/proc_macro_api/Cargo.toml
+++ b/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"
diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs
index 2ea456fb096..cec85474670 100644
--- a/crates/proc_macro_api/src/lib.rs
+++ b/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::{
- ffi::OsStr,
- io,
- path::{Path, PathBuf},
- sync::Arc,
-};
+use std::{ffi::OsStr, fs::read as fsread, io::{self, Read}, 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
+ }
}
From 8fd7cd74067445484fbbd3f78e715c4fe24b004c Mon Sep 17 00:00:00 2001
From: Jay Somedon <jay.somedon@outlook.com>
Date: Wed, 23 Dec 2020 17:57:43 +0800
Subject: [PATCH 2/8] Configure object crate's feature
Signed-off-by: Jay Somedon <jay.somedon@outlook.com>
---
crates/proc_macro_api/Cargo.toml | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/crates/proc_macro_api/Cargo.toml b/crates/proc_macro_api/Cargo.toml
index a72ae236af9..5b0a05dffd4 100644
--- a/crates/proc_macro_api/Cargo.toml
+++ b/crates/proc_macro_api/Cargo.toml
@@ -20,4 +20,4 @@ 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"
+object = { version = "0.23.0", default-features = false, features = ["std", "read_core", "elf", "macho", "pe", "unaligned"] }
From 55d73bc6754c351dead6ab4d4b57ddaa347734d6 Mon Sep 17 00:00:00 2001
From: Jay Somedon <jay.somedon@outlook.com>
Date: Wed, 23 Dec 2020 21:24:53 +0800
Subject: [PATCH 3/8] Fix multiple issues from code review
* check metadata version
* use memmap
* use Result instead of unwrap
with Jay Somedon <jay.somedon@outlook.com>
---
Cargo.lock | 33 ++++++++++--------------
crates/proc_macro_api/Cargo.toml | 1 +
crates/proc_macro_api/src/lib.rs | 44 +++++++++++++++++++++-----------
3 files changed, 44 insertions(+), 34 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index b61fd2e9812..39f43ba17f8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -80,7 +80,7 @@ dependencies = [
"cfg-if",
"libc",
"miniz_oxide",
- "object 0.23.0",
+ "object",
"rustc-demangle",
]
@@ -891,6 +891,16 @@ version = "2.3.4"
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"
@@ -1008,16 +1018,6 @@ 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"
@@ -1164,7 +1164,8 @@ dependencies = [
"crossbeam-channel",
"jod-thread",
"log",
- "object 0.22.0",
+ "memmap",
+ "object",
"serde",
"serde_json",
"snap",
@@ -1180,7 +1181,7 @@ dependencies = [
"libloading",
"mbe",
"memmap2",
- "object 0.23.0",
+ "object",
"proc_macro_api",
"proc_macro_test",
"serde_derive",
@@ -1898,12 +1899,6 @@ 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"
diff --git a/crates/proc_macro_api/Cargo.toml b/crates/proc_macro_api/Cargo.toml
index 5b0a05dffd4..16fd56c7ecc 100644
--- a/crates/proc_macro_api/Cargo.toml
+++ b/crates/proc_macro_api/Cargo.toml
@@ -21,3 +21,4 @@ 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 cec85474670..a58e39de010 100644
--- a/crates/proc_macro_api/src/lib.rs
+++ b/crates/proc_macro_api/src/lib.rs
@@ -9,15 +9,22 @@ pub mod msg;
mod process;
mod rpc;
-use std::{ffi::OsStr, fs::read as fsread, io::{self, Read}, path::{Path, PathBuf}, sync::Arc};
-
use base_db::{Env, ProcMacro};
+use std::{
+ ffi::OsStr,
+ fs::File,
+ io::{self, Read},
+ path::{Path, PathBuf},
+ sync::Arc,
+};
+
use tt::{SmolStr, Subtree};
use crate::process::{ProcMacroProcessSrv, ProcMacroProcessThread};
pub use rpc::{ExpansionResult, ExpansionTask, ListMacrosResult, ListMacrosTask, ProcMacroKind};
+use memmap::Mmap;
use object::read::{File as BinaryFile, Object, ObjectSection};
use snap::read::FrameDecoder as SnapDecoder;
@@ -110,13 +117,13 @@ impl ProcMacroClient {
// 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] {
+ fn read_section<'a>(&self, dylib_binary: &'a [u8], section_name: &str) -> io::Result<&'a [u8]> {
BinaryFile::parse(dylib_binary)
- .unwrap()
+ .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?
.section_by_name(section_name)
- .unwrap()
+ .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "section read error"))?
.data()
- .unwrap()
+ .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
@@ -138,10 +145,19 @@ impl ProcMacroClient {
// * [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();
+ #[allow(unused)]
+ fn read_version(&self, dylib_path: &Path) -> io::Result<String> {
+ let dylib_file = File::open(dylib_path)?;
+ let dylib_mmaped = unsafe { Mmap::map(&dylib_file) }?;
- let dot_rustc = self.read_section(&dylib_binary, ".rustc");
+ let dot_rustc = self.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!(".rustc section should start with header {:?}; header {:?} is actually presented.",EXPECTED_HEADER ,header)));
+ }
let snappy_portion = &dot_rustc[8..];
@@ -154,14 +170,12 @@ impl ProcMacroClient {
// 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();
+ 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).unwrap();
- let version_string = String::from_utf8(version_string_utf8).unwrap();
- version_string
+ 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))
}
}
From c92db2abf989e76f6c6a4407c5ac3bfa7262c19a Mon Sep 17 00:00:00 2001
From: Jay Somedon <jay.somedon@outlook.com>
Date: Wed, 23 Dec 2020 22:04:39 +0800
Subject: [PATCH 4/8] Update comment
Co-authored-by: Jonas Schievink <jonasschievink@gmail.com>
---
crates/proc_macro_api/src/lib.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs
index a58e39de010..34a4e68ab78 100644
--- a/crates/proc_macro_api/src/lib.rs
+++ b/crates/proc_macro_api/src/lib.rs
@@ -132,7 +132,7 @@ impl ProcMacroClient {
// * [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
+ // snappy compression format. Version info is inside here, so decompress
// this.
// The bytes you get after decompressing the snappy format portion has
// following layout:
From a8f7326ee58185e3b2b95076b8542ef6afc80a5f Mon Sep 17 00:00:00 2001
From: Jay Somedon <jay.somedon@outlook.com>
Date: Wed, 23 Dec 2020 22:19:27 +0800
Subject: [PATCH 5/8] Update condition check code style
Co-authored-by: Jonas Schievink <jonasschievink@gmail.com>
---
crates/proc_macro_api/src/lib.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs
index 34a4e68ab78..481fb6deead 100644
--- a/crates/proc_macro_api/src/lib.rs
+++ b/crates/proc_macro_api/src/lib.rs
@@ -155,7 +155,7 @@ impl ProcMacroClient {
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) {
+ if header != EXPECTED_HEADER {
return Err(io::Error::new(io::ErrorKind::InvalidData, format!(".rustc section should start with header {:?}; header {:?} is actually presented.",EXPECTED_HEADER ,header)));
}
From 0669abda4aa2a544ad8ab465fba0853ff8379c23 Mon Sep 17 00:00:00 2001
From: Jay Somedon <jay.somedon@outlook.com>
Date: Thu, 24 Dec 2020 23:00:59 +0800
Subject: [PATCH 6/8] Revise error message regarding metadata version
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Co-authored-by: Laurențiu Nicola <lnicola@users.noreply.github.com>
---
crates/proc_macro_api/src/lib.rs | 16 ++++++----------
1 file changed, 6 insertions(+), 10 deletions(-)
diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs
index 481fb6deead..8f0f141f719 100644
--- a/crates/proc_macro_api/src/lib.rs
+++ b/crates/proc_macro_api/src/lib.rs
@@ -76,10 +76,7 @@ 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> {
@@ -106,11 +103,7 @@ impl ProcMacroClient {
dylib_path: dylib_path.into(),
});
- ProcMacro {
- name,
- kind,
- expander,
- }
+ ProcMacro { name, kind, expander }
})
.collect()
}
@@ -156,7 +149,10 @@ impl ProcMacroClient {
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!(".rustc section should start with header {:?}; header {:?} is actually presented.",EXPECTED_HEADER ,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..];
From cc8c40480a34aa1d233d9a34b505bee16897ef54 Mon Sep 17 00:00:00 2001
From: Edwin Cheng <edwin0cheng@gmail.com>
Date: Thu, 4 Mar 2021 10:48:12 +0800
Subject: [PATCH 7/8] Print warning if proc-macro built by old rustc
---
crates/proc_macro_api/src/lib.rs | 90 ++++--------------
crates/proc_macro_api/src/version.rs | 131 +++++++++++++++++++++++++++
2 files changed, 148 insertions(+), 73 deletions(-)
create mode 100644 crates/proc_macro_api/src/version.rs
diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs
index 8f0f141f719..941d0fe9e21 100644
--- a/crates/proc_macro_api/src/lib.rs
+++ b/crates/proc_macro_api/src/lib.rs
@@ -8,12 +8,12 @@
pub mod msg;
mod process;
mod rpc;
+mod version;
use base_db::{Env, ProcMacro};
use std::{
ffi::OsStr,
- fs::File,
- io::{self, Read},
+ io,
path::{Path, PathBuf},
sync::Arc,
};
@@ -24,10 +24,6 @@ use crate::process::{ProcMacroProcessSrv, ProcMacroProcessThread};
pub use rpc::{ExpansionResult, ExpansionTask, ListMacrosResult, ListMacrosTask, ProcMacroKind};
-use memmap::Mmap;
-use object::read::{File as BinaryFile, Object, ObjectSection};
-use snap::read::FrameDecoder as SnapDecoder;
-
#[derive(Debug, Clone)]
struct ProcMacroProcessExpander {
process: Arc<ProcMacroProcessSrv>,
@@ -80,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);
@@ -107,71 +118,4 @@ impl ProcMacroClient {
})
.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) -> 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
- #[allow(unused)]
- fn read_version(&self, dylib_path: &Path) -> io::Result<String> {
- let dylib_file = File::open(dylib_path)?;
- let dylib_mmaped = unsafe { Mmap::map(&dylib_file) }?;
-
- let dot_rustc = self.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))
- }
}
diff --git a/crates/proc_macro_api/src/version.rs b/crates/proc_macro_api/src/version.rs
new file mode 100644
index 00000000000..80cd183a08b
--- /dev/null
+++ b/crates/proc_macro_api/src/version.rs
@@ -0,0 +1,131 @@
+//! 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))
+}
From ad34e79bb9818cc9bf3d0cf746bd052a67c7bab9 Mon Sep 17 00:00:00 2001
From: Edwin Cheng <edwin0cheng@gmail.com>
Date: Wed, 10 Mar 2021 04:54:31 +0800
Subject: [PATCH 8/8] use doc-comments
---
crates/proc_macro_api/src/version.rs | 43 ++++++++++++++--------------
1 file changed, 22 insertions(+), 21 deletions(-)
diff --git a/crates/proc_macro_api/src/version.rs b/crates/proc_macro_api/src/version.rs
index 80cd183a08b..11a7fb59a3b 100644
--- a/crates/proc_macro_api/src/version.rs
+++ b/crates/proc_macro_api/src/version.rs
@@ -64,8 +64,8 @@ pub(crate) fn read_info(dylib_path: &Path) -> io::Result<RustCInfo> {
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.
+/// 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))?
@@ -75,25 +75,26 @@ fn read_section<'a>(dylib_binary: &'a [u8], section_name: &str) -> io::Result<&'
.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
+/// 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) }?;