Auto merge of #157683 - jhpratt:rollup-n3DkSzN, r=jhpratt

Rollup of 17 pull requests



Successful merges:

 - rust-lang/rust#157166 (Change type of async context parameter after state transform.)
 - rust-lang/rust#157335 (bootstrap: Handle dotted table keys when parsing bootstrap.toml)
 - rust-lang/rust#157503 (Disable `tests/debuginfo/pretty-std.rs` `OsString` cdb check)
 - rust-lang/rust#157571 (Remove ProcMacro enum from proc macro ABI)
 - rust-lang/rust#148183 (rustdoc: Test & document `test_harness` code block attribute)
 - rust-lang/rust#153847 (Fix marker trait winnowing depending on impl order)
 - rust-lang/rust#156067 (Fix async drop glue for Box<T>)
 - rust-lang/rust#156399 (fix improper ctypes in Znext solver)
 - rust-lang/rust#157338 (Make `Literal::byte_character_value` work with bytes as well)
 - rust-lang/rust#157410 (Implement rustc_public::CrateDef{,Type} for FieldDef)
 - rust-lang/rust#157605 (Arg splat experiment - syntax impl)
 - rust-lang/rust#157630 (Add multibyte JSON diagnostic regression test)
 - rust-lang/rust#157633 (Reorder `impl` restriction rendering and add bottom margin)
 - rust-lang/rust#157642 (Report duplicate relaxed bounds during ast lowering)
 - rust-lang/rust#157652 (fix doc for unicode normalization faq on `casefold` APIs)
 - rust-lang/rust#157661 (Update to ar_archive_writer v0.5.2)
 - rust-lang/rust#157668 (Add test for matches in `rustc_must_match_exhaustively`)

Failed merges:

 - rust-lang/rust#157670 (Rename `errors.rs` file to `diagnostics.rs` (4/N))

Author: bors

crates/proc-macro-srv/Cargo.toml

@@ -35,8 +35,7 @@ line-index.workspace = true
 proc-macro-test.path = "./proc-macro-test"
 
 [features]
-default = []
-# default = ["in-rust-tree"]
+default = ["in-rust-tree"]
 in-rust-tree = []
 
 [lints]

crates/proc-macro-srv/src/dylib.rs

@@ -1,9 +1,14 @@
 //! Handles dynamic library loading for proc macro
 
 mod proc_macros;
-mod version;
 
+use rustc_codegen_ssa::back::metadata::DefaultMetadataLoader;
+use rustc_interface::util::rustc_version_str;
+use rustc_metadata::locator::MetadataError;
 use rustc_proc_macro::bridge;
+use rustc_session::config::host_tuple;
+use rustc_target::spec::{Target, TargetTuple};
+use std::path::Path;
 use std::{fmt, fs, io, time::SystemTime};
 use temp_dir::TempDir;
 
@@ -13,7 +18,8 @@ use paths::{Utf8Path, Utf8PathBuf};
 
 use crate::{
     PanicMessage, ProcMacroClientHandle, ProcMacroKind, ProcMacroSrvSpan, TrackedEnv,
-    dylib::proc_macros::ProcMacros, token_stream::TokenStream,
+    dylib::proc_macros::{ProcMacroClients, ProcMacros},
+    token_stream::TokenStream,
 };
 
 pub(crate) struct Expander {
@@ -76,18 +82,15 @@ impl Expander {
 pub enum LoadProcMacroDylibError {
     Io(io::Error),
     LibLoading(libloading::Error),
-    AbiMismatch(String),
+    MetadataError(MetadataError<'static>),
 }
 
 impl fmt::Display for LoadProcMacroDylibError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::Io(e) => e.fmt(f),
-            Self::AbiMismatch(v) => {
-                use crate::RUSTC_VERSION_STRING;
-                write!(f, "mismatched ABI expected: `{RUSTC_VERSION_STRING}`, got `{v}`")
-            }
             Self::LibLoading(e) => e.fmt(f),
+            Self::MetadataError(e) => e.fmt(f),
         }
     }
 }
@@ -104,25 +107,44 @@ impl From<libloading::Error> for LoadProcMacroDylibError {
     }
 }
 
+impl From<MetadataError<'_>> for LoadProcMacroDylibError {
+    fn from(e: MetadataError<'_>) -> Self {
+        LoadProcMacroDylibError::MetadataError(match e {
+            MetadataError::NotPresent(path) => MetadataError::NotPresent(path.into_owned().into()),
+            MetadataError::LoadFailure(err) => MetadataError::LoadFailure(err),
+            MetadataError::VersionMismatch { expected_version, found_version } => {
+                MetadataError::VersionMismatch { expected_version, found_version }
+            }
+        })
+    }
+}
+
 struct ProcMacroLibrary {
-    // 'static is actually the lifetime of library, so make sure this drops before _lib
-    proc_macros: &'static ProcMacros,
+    // this contains references to the library, so make sure this drops before _lib
+    proc_macros: ProcMacros,
     // Hold on to the library so it doesn't unload
     _lib: Library,
 }
 
 impl ProcMacroLibrary {
     fn open(path: &Utf8Path) -> Result<Self, LoadProcMacroDylibError> {
+        let proc_macro_kinds = rustc_span::create_default_session_globals_then(|| {
+            let (target, _) =
+                Target::search(&TargetTuple::from_tuple(host_tuple()), Path::new(""), false)
+                    .unwrap();
+            rustc_metadata::locator::get_proc_macro_info(
+                &target,
+                path.as_ref(),
+                &DefaultMetadataLoader,
+                rustc_version_str().unwrap_or("unknown"),
+            )
+        })?;
+
         let file = fs::File::open(path)?;
         #[allow(clippy::undocumented_unsafe_blocks)] // FIXME
         let file = unsafe { memmap2::Mmap::map(&file) }?;
         let obj = object::File::parse(&*file)
             .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
-        let version_info = version::read_dylib_info(&obj)?;
-        if version_info.version_string != crate::RUSTC_VERSION_STRING {
-            return Err(LoadProcMacroDylibError::AbiMismatch(version_info.version_string));
-        }
-
         let symbol_name =
             find_registrar_symbol(&obj).map_err(invalid_data_err)?.ok_or_else(|| {
                 invalid_data_err(format!("Cannot find registrar symbol in file {path}"))
@@ -135,9 +157,12 @@ impl ProcMacroLibrary {
         // due to self-referentiality
         // But we make sure that we do not drop it before the symbol is dropped
         let proc_macros =
-            unsafe { lib.get::<&'static &'static ProcMacros>(symbol_name.as_bytes()) };
+            unsafe { lib.get::<&'static &'static ProcMacroClients>(symbol_name.as_bytes()) };
         match proc_macros {
-            Ok(proc_macros) => Ok(ProcMacroLibrary { proc_macros: *proc_macros, _lib: lib }),
+            Ok(proc_macros) => Ok(ProcMacroLibrary {
+                proc_macros: ProcMacros::new(*proc_macros, proc_macro_kinds),
+                _lib: lib,
+            }),
             Err(e) => Err(e.into()),
         }
     }

crates/proc-macro-srv/src/dylib/proc_macros.rs

@@ -5,15 +5,24 @@ use crate::{
 use rustc_proc_macro::bridge;
 
 #[repr(transparent)]
-pub(crate) struct ProcMacros([bridge::client::ProcMacro]);
+pub(crate) struct ProcMacroClients([bridge::client::Client]);
 
 impl From<bridge::PanicMessage> for crate::PanicMessage {
     fn from(p: bridge::PanicMessage) -> Self {
         Self { message: p.into_string() }
     }
 }
 
+pub(crate) struct ProcMacros(Vec<(bridge::client::Client, rustc_metadata::ProcMacroKind)>);
+
 impl ProcMacros {
+    pub(super) fn new(
+        clients: &ProcMacroClients,
+        kinds: Vec<rustc_metadata::ProcMacroKind>,
+    ) -> Self {
+        ProcMacros(clients.0.iter().copied().zip(kinds).collect::<Vec<_>>())
+    }
+
     pub(crate) fn expand<'a, S: ProcMacroSrvSpan>(
         &self,
         macro_name: &str,
@@ -27,30 +36,30 @@ impl ProcMacros {
     ) -> Result<TokenStream<S>, crate::PanicMessage> {
         let parsed_attributes = attribute.unwrap_or_default();
 
-        for proc_macro in &self.0 {
-            match proc_macro {
-                bridge::client::ProcMacro::CustomDerive { trait_name, client, .. }
-                    if *trait_name == macro_name =>
+        for (client, kind) in &self.0 {
+            match kind {
+                rustc_metadata::ProcMacroKind::CustomDerive { trait_name, .. }
+                    if trait_name.as_str() == macro_name =>
                 {
-                    let res = client.run(
+                    let res = client.run1(
                         &bridge::server::SAME_THREAD,
                         S::make_server(call_site, def_site, mixed_site, tracked_env, callback),
                         macro_body,
                         cfg!(debug_assertions),
                     );
                     return res.map_err(crate::PanicMessage::from);
                 }
-                bridge::client::ProcMacro::Bang { name, client } if *name == macro_name => {
-                    let res = client.run(
+                rustc_metadata::ProcMacroKind::Bang { name } if name.as_str() == macro_name => {
+                    let res = client.run1(
                         &bridge::server::SAME_THREAD,
                         S::make_server(call_site, def_site, mixed_site, tracked_env, callback),
                         macro_body,
                         cfg!(debug_assertions),
                     );
                     return res.map_err(crate::PanicMessage::from);
                 }
-                bridge::client::ProcMacro::Attr { name, client } if *name == macro_name => {
-                    let res = client.run(
+                rustc_metadata::ProcMacroKind::Attr { name } if name.as_str() == macro_name => {
+                    let res = client.run2(
                         &bridge::server::SAME_THREAD,
                         S::make_server(call_site, def_site, mixed_site, tracked_env, callback),
                         parsed_attributes,
@@ -67,12 +76,16 @@ impl ProcMacros {
     }
 
     pub(crate) fn list_macros(&self) -> impl Iterator<Item = (&str, ProcMacroKind)> {
-        self.0.iter().map(|proc_macro| match *proc_macro {
-            bridge::client::ProcMacro::CustomDerive { trait_name, .. } => {
-                (trait_name, ProcMacroKind::CustomDerive)
+        self.0.iter().map(|(_client, kind)| match kind {
+            rustc_metadata::ProcMacroKind::CustomDerive { trait_name, .. } => {
+                (trait_name.as_str(), ProcMacroKind::CustomDerive)
+            }
+            rustc_metadata::ProcMacroKind::Bang { name, .. } => {
+                (name.as_str(), ProcMacroKind::Bang)
+            }
+            rustc_metadata::ProcMacroKind::Attr { name, .. } => {
+                (name.as_str(), ProcMacroKind::Attr)
             }
-            bridge::client::ProcMacro::Bang { name, .. } => (name, ProcMacroKind::Bang),
-            bridge::client::ProcMacro::Attr { name, .. } => (name, ProcMacroKind::Attr),
         })
     }
 }

crates/proc-macro-srv/src/dylib/version.rs

@@ -14,9 +14,15 @@
 #![allow(unused_features, unused_crate_dependencies)]
 #![deny(deprecated_safe, clippy::undocumented_unsafe_blocks)]
 
+extern crate rustc_codegen_ssa;
 extern crate rustc_driver as _;
+extern crate rustc_interface;
 extern crate rustc_lexer;
+extern crate rustc_metadata;
 extern crate rustc_proc_macro;
+extern crate rustc_session;
+extern crate rustc_span;
+extern crate rustc_target;
 
 mod bridge;
 mod dylib;