Deny unreachable-pub

It's very useful when `pub` is equivalent to "this is crate's public
API", let's enforce this!

Ideally, we should enforce it for local `cargo test`, and only during
CI, but that needs https://github.com/rust-lang/cargo/issues/5034.

2 files changed, 21 insertions, 21 deletions

diff --git a/crates/proc_macro_api/src/process.rs b/crates/proc_macro_api/src/process.rs
index 51ffcaa78..907cb3db7 100644
--- a/crates/proc_macro_api/src/process.rs
+++ b/crates/proc_macro_api/src/process.rs
@@ -30,7 +30,7 @@ pub(crate) struct ProcMacroProcessThread {
 }
 
 impl ProcMacroProcessSrv {
-    pub fn run(
+    pub(crate) fn run(
         process_path: PathBuf,
         args: impl IntoIterator<Item = impl AsRef<OsStr>>,
     ) -> io::Result<(ProcMacroProcessThread, ProcMacroProcessSrv)> {
@@ -48,7 +48,7 @@ impl ProcMacroProcessSrv {
         Ok((thread, srv))
     }
 
-    pub fn find_proc_macros(
+    pub(crate) fn find_proc_macros(
         &self,
         dylib_path: &Path,
     ) -> Result<Vec<(String, ProcMacroKind)>, tt::ExpansionError> {
@@ -58,7 +58,7 @@ impl ProcMacroProcessSrv {
         Ok(result.macros)
     }
 
-    pub fn custom_derive(
+    pub(crate) fn custom_derive(
         &self,
         dylib_path: &Path,
         subtree: &Subtree,
@@ -75,7 +75,7 @@ impl ProcMacroProcessSrv {
         Ok(result.expansion)
     }
 
-    pub fn send_task<R>(&self, req: Request) -> Result<R, tt::ExpansionError>
+    pub(crate) fn send_task<R>(&self, req: Request) -> Result<R, tt::ExpansionError>
     where
         R: TryFrom<Response, Error = &'static str>,
     {
diff --git a/crates/proc_macro_api/src/rpc.rs b/crates/proc_macro_api/src/rpc.rs
index 47624163e..203109ca4 100644
--- a/crates/proc_macro_api/src/rpc.rs
+++ b/crates/proc_macro_api/src/rpc.rs
@@ -75,18 +75,18 @@ struct TokenIdDef(u32);
 #[serde(remote = "Delimiter")]
 struct DelimiterDef {
     #[serde(with = "TokenIdDef")]
-    pub id: TokenId,
+    id: TokenId,
     #[serde(with = "DelimiterKindDef")]
-    pub kind: DelimiterKind,
+    kind: DelimiterKind,
 }
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "Subtree")]
 struct SubtreeDef {
     #[serde(default, with = "opt_delimiter_def")]
-    pub delimiter: Option<Delimiter>,
+    delimiter: Option<Delimiter>,
     #[serde(with = "vec_token_tree")]
-    pub token_trees: Vec<TokenTree>,
+    token_trees: Vec<TokenTree>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -112,19 +112,19 @@ enum LeafDef {
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "Literal")]
 struct LiteralDef {
-    pub text: SmolStr,
+    text: SmolStr,
     #[serde(with = "TokenIdDef")]
-    pub id: TokenId,
+    id: TokenId,
 }
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "Punct")]
 struct PunctDef {
-    pub char: char,
+    char: char,
     #[serde(with = "SpacingDef")]
-    pub spacing: Spacing,
+    spacing: Spacing,
     #[serde(with = "TokenIdDef")]
-    pub id: TokenId,
+    id: TokenId,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -137,16 +137,16 @@ enum SpacingDef {
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "Ident")]
 struct IdentDef {
-    pub text: SmolStr,
+    text: SmolStr,
     #[serde(with = "TokenIdDef")]
-    pub id: TokenId,
+    id: TokenId,
 }
 
 mod opt_delimiter_def {
     use super::{Delimiter, DelimiterDef};
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-    pub fn serialize<S>(value: &Option<Delimiter>, serializer: S) -> Result<S::Ok, S::Error>
+    pub(super) fn serialize<S>(value: &Option<Delimiter>, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
@@ -155,7 +155,7 @@ mod opt_delimiter_def {
         value.as_ref().map(Helper).serialize(serializer)
     }
 
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Delimiter>, D::Error>
+    pub(super) fn deserialize<'de, D>(deserializer: D) -> Result<Option<Delimiter>, D::Error>
     where
         D: Deserializer<'de>,
     {
@@ -170,7 +170,7 @@ mod opt_subtree_def {
     use super::{Subtree, SubtreeDef};
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-    pub fn serialize<S>(value: &Option<Subtree>, serializer: S) -> Result<S::Ok, S::Error>
+    pub(super) fn serialize<S>(value: &Option<Subtree>, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
@@ -179,7 +179,7 @@ mod opt_subtree_def {
         value.as_ref().map(Helper).serialize(serializer)
     }
 
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Subtree>, D::Error>
+    pub(super) fn deserialize<'de, D>(deserializer: D) -> Result<Option<Subtree>, D::Error>
     where
         D: Deserializer<'de>,
     {
@@ -194,7 +194,7 @@ mod vec_token_tree {
     use super::{TokenTree, TokenTreeDef};
     use serde::{ser::SerializeSeq, Deserialize, Deserializer, Serialize, Serializer};
 
-    pub fn serialize<S>(value: &Vec<TokenTree>, serializer: S) -> Result<S::Ok, S::Error>
+    pub(super) fn serialize<S>(value: &Vec<TokenTree>, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
@@ -209,7 +209,7 @@ mod vec_token_tree {
         seq.end()
     }
 
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<TokenTree>, D::Error>
+    pub(super) fn deserialize<'de, D>(deserializer: D) -> Result<Vec<TokenTree>, D::Error>
     where
         D: Deserializer<'de>,
     {