Treewide: Remove unreachable pub

Some structs / fields etc were marked as pub despite not being a part of
public API. This is confusing when reading code: in order to know if
something is truly public you need to check all the modules up to lib.rs
to verify that each appears in some `pub use`.

This commit removes all such occurrences - now something is public if and
only if it is marked as pub.

Author: Lorak-mmk

scylla-macros/src/from_row.rs

@@ -3,7 +3,7 @@ use quote::{quote, quote_spanned};
 use syn::{spanned::Spanned, DeriveInput};
 
 /// #[derive(FromRow)] derives FromRow for struct
-pub fn from_row_derive(tokens_input: TokenStream) -> Result<TokenStream, syn::Error> {
+pub(crate) fn from_row_derive(tokens_input: TokenStream) -> Result<TokenStream, syn::Error> {
     let item = syn::parse::<DeriveInput>(tokens_input)?;
     let path = crate::parser::get_path(&item)?;
     let struct_fields = crate::parser::parse_named_fields(&item, "FromRow")?;

scylla-macros/src/from_user_type.rs

@@ -3,7 +3,7 @@ use quote::{quote, quote_spanned};
 use syn::{spanned::Spanned, DeriveInput};
 
 /// #[derive(FromUserType)] allows to parse a struct as User Defined Type
-pub fn from_user_type_derive(tokens_input: TokenStream) -> Result<TokenStream, syn::Error> {
+pub(crate) fn from_user_type_derive(tokens_input: TokenStream) -> Result<TokenStream, syn::Error> {
     let item = syn::parse::<DeriveInput>(tokens_input)?;
     let path = crate::parser::get_path(&item)?;
     let struct_fields = crate::parser::parse_named_fields(&item, "FromUserType")?;

scylla-macros/src/into_user_type.rs

@@ -3,7 +3,7 @@ use quote::{quote, quote_spanned};
 use syn::{spanned::Spanned, DeriveInput};
 
 /// #[derive(IntoUserType)] allows to parse a struct as User Defined Type
-pub fn into_user_type_derive(tokens_input: TokenStream) -> Result<TokenStream, syn::Error> {
+pub(crate) fn into_user_type_derive(tokens_input: TokenStream) -> Result<TokenStream, syn::Error> {
     let item = syn::parse::<DeriveInput>(tokens_input)?;
     let path = crate::parser::get_path(&item)?;
     let struct_fields = crate::parser::parse_named_fields(&item, "IntoUserType")?;

scylla-macros/src/serialize/cql.rs

@@ -61,7 +61,7 @@ struct Context {
     fields: Vec<Field>,
 }
 
-pub fn derive_serialize_cql(tokens_input: TokenStream) -> Result<syn::ItemImpl, syn::Error> {
+pub(crate) fn derive_serialize_cql(tokens_input: TokenStream) -> Result<syn::ItemImpl, syn::Error> {
     let input: syn::DeriveInput = syn::parse(tokens_input)?;
     let struct_name = input.ident.clone();
     let named_fields = crate::parser::parse_named_fields(&input, "SerializeCql")?;

scylla-macros/src/serialize/row.rs

@@ -58,7 +58,7 @@ struct Context {
     fields: Vec<Field>,
 }
 
-pub fn derive_serialize_row(tokens_input: TokenStream) -> Result<syn::ItemImpl, syn::Error> {
+pub(crate) fn derive_serialize_row(tokens_input: TokenStream) -> Result<syn::ItemImpl, syn::Error> {
     let input: syn::DeriveInput = syn::parse(tokens_input)?;
     let struct_name = input.ident.clone();
     let named_fields = crate::parser::parse_named_fields(&input, "SerializeRow")?;

scylla-macros/src/value_list.rs

@@ -4,7 +4,7 @@ use syn::DeriveInput;
 
 /// #[derive(ValueList)] allows to parse a struct as a list of values,
 /// which can be fed to the query directly.
-pub fn value_list_derive(tokens_input: TokenStream) -> Result<TokenStream, syn::Error> {
+pub(crate) fn value_list_derive(tokens_input: TokenStream) -> Result<TokenStream, syn::Error> {
     let item = syn::parse::<DeriveInput>(tokens_input)?;
     let path = crate::parser::get_path(&item)?;
     let struct_fields = crate::parser::parse_named_fields(&item, "ValueList")?;

scylla-proxy/src/frame.rs

@@ -43,7 +43,7 @@ pub(crate) enum FrameType {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum FrameOpcode {
+pub(crate) enum FrameOpcode {
     Request(RequestOpcode),
     Response(ResponseOpcode),
 }

scylla/src/transport/connection.rs

@@ -301,15 +301,15 @@ mod ssl_config {
     // for the particular node. (The SslConfig must be different, because SNIs differ for different nodes.)
     // Thenceforth, all connections to that node share the same SslConfig.
     #[derive(Clone)]
-    pub struct SslConfig {
+    pub(crate) struct SslConfig {
         context: SslContext,
         #[cfg(feature = "cloud")]
         sni: Option<String>,
     }
 
     impl SslConfig {
         // Used in case when the user provided their own SslContext to be used in all connections.
-        pub fn new_with_global_context(context: SslContext) -> Self {
+        pub(crate) fn new_with_global_context(context: SslContext) -> Self {
             Self {
                 context,
                 #[cfg(feature = "cloud")]
@@ -349,24 +349,24 @@ mod ssl_config {
 }
 
 #[derive(Clone)]
-pub struct ConnectionConfig {
-    pub compression: Option<Compression>,
-    pub tcp_nodelay: bool,
-    pub tcp_keepalive_interval: Option<Duration>,
+pub(crate) struct ConnectionConfig {
+    pub(crate) compression: Option<Compression>,
+    pub(crate) tcp_nodelay: bool,
+    pub(crate) tcp_keepalive_interval: Option<Duration>,
     #[cfg(feature = "ssl")]
-    pub ssl_config: Option<SslConfig>,
-    pub connect_timeout: std::time::Duration,
+    pub(crate) ssl_config: Option<SslConfig>,
+    pub(crate) connect_timeout: std::time::Duration,
     // should be Some only in control connections,
-    pub event_sender: Option<mpsc::Sender<Event>>,
-    pub default_consistency: Consistency,
+    pub(crate) event_sender: Option<mpsc::Sender<Event>>,
+    pub(crate) default_consistency: Consistency,
     #[cfg(feature = "cloud")]
     pub(crate) cloud_config: Option<Arc<CloudConfig>>,
-    pub authenticator: Option<Arc<dyn AuthenticatorProvider>>,
-    pub address_translator: Option<Arc<dyn AddressTranslator>>,
-    pub enable_write_coalescing: bool,
+    pub(crate) authenticator: Option<Arc<dyn AuthenticatorProvider>>,
+    pub(crate) address_translator: Option<Arc<dyn AddressTranslator>>,
+    pub(crate) enable_write_coalescing: bool,
 
-    pub keepalive_interval: Option<Duration>,
-    pub keepalive_timeout: Option<Duration>,
+    pub(crate) keepalive_interval: Option<Duration>,
+    pub(crate) keepalive_timeout: Option<Duration>,
 }
 
 impl Default for ConnectionConfig {
@@ -395,7 +395,7 @@ impl Default for ConnectionConfig {
 
 impl ConnectionConfig {
     #[cfg(feature = "ssl")]
-    pub fn is_ssl(&self) -> bool {
+    fn is_ssl(&self) -> bool {
         #[cfg(feature = "cloud")]
         if self.cloud_config.is_some() {
             return true;
@@ -404,7 +404,7 @@ impl ConnectionConfig {
     }
 
     #[cfg(not(feature = "ssl"))]
-    pub fn is_ssl(&self) -> bool {
+    fn is_ssl(&self) -> bool {
         false
     }
 }

scylla/src/transport/cql_types_test.rs

@@ -1531,8 +1531,8 @@ async fn test_udt_after_schema_update() {
     #[derive(SerializeCql, FromUserType, Debug, PartialEq)]
     #[scylla(crate = crate)]
     struct UdtV1 {
-        pub first: i32,
-        pub second: bool,
+        first: i32,
+        second: bool,
     }
 
     let v1 = UdtV1 {
@@ -1592,9 +1592,9 @@ async fn test_udt_after_schema_update() {
 
     #[derive(FromUserType, Debug, PartialEq)]
     struct UdtV2 {
-        pub first: i32,
-        pub second: bool,
-        pub third: Option<String>,
+        first: i32,
+        second: bool,
+        third: Option<String>,
     }
 
     let (read_udt,): (UdtV2,) = session
@@ -1748,17 +1748,17 @@ async fn test_udt_with_missing_field() {
 
     #[derive(FromUserType, Debug, PartialEq)]
     struct UdtFull {
-        pub first: i32,
-        pub second: bool,
-        pub third: Option<f32>,
-        pub fourth: Option<Vec<u8>>,
+        first: i32,
+        second: bool,
+        third: Option<f32>,
+        fourth: Option<Vec<u8>>,
     }
 
     #[derive(SerializeCql)]
     #[scylla(crate = crate)]
     struct UdtV1 {
-        pub first: i32,
-        pub second: bool,
+        first: i32,
+        second: bool,
     }
 
     verify_insert_select_identity(
@@ -1783,9 +1783,9 @@ async fn test_udt_with_missing_field() {
     #[derive(SerializeCql)]
     #[scylla(crate = crate)]
     struct UdtV2 {
-        pub first: i32,
-        pub second: bool,
-        pub third: Option<f32>,
+        first: i32,
+        second: bool,
+        third: Option<f32>,
     }
 
     verify_insert_select_identity(
@@ -1811,9 +1811,9 @@ async fn test_udt_with_missing_field() {
     #[derive(SerializeCql)]
     #[scylla(crate = crate)]
     struct UdtV3 {
-        pub first: i32,
-        pub second: bool,
-        pub fourth: Option<Vec<u8>>,
+        first: i32,
+        second: bool,
+        fourth: Option<Vec<u8>>,
     }
 
     verify_insert_select_identity(
@@ -1839,8 +1839,8 @@ async fn test_udt_with_missing_field() {
     #[derive(SerializeCql)]
     #[scylla(crate = crate, flavor="enforce_order")]
     struct UdtV4 {
-        pub first: i32,
-        pub second: bool,
+        first: i32,
+        second: bool,
     }
 
     verify_insert_select_identity(

scylla/src/transport/execution_profile.rs

@@ -179,22 +179,22 @@ pub(crate) mod defaults {
     use scylla_cql::Consistency;
     use std::sync::Arc;
     use std::time::Duration;
-    pub fn consistency() -> Consistency {
+    pub(crate) fn consistency() -> Consistency {
         Consistency::LocalQuorum
     }
-    pub fn serial_consistency() -> Option<SerialConsistency> {
+    pub(crate) fn serial_consistency() -> Option<SerialConsistency> {
         Some(SerialConsistency::LocalSerial)
     }
-    pub fn request_timeout() -> Option<Duration> {
+    pub(crate) fn request_timeout() -> Option<Duration> {
         Some(Duration::from_secs(30))
     }
-    pub fn load_balancing_policy() -> Arc<dyn LoadBalancingPolicy> {
+    pub(crate) fn load_balancing_policy() -> Arc<dyn LoadBalancingPolicy> {
         Arc::new(load_balancing::DefaultPolicy::default())
     }
-    pub fn retry_policy() -> Box<dyn RetryPolicy> {
+    pub(crate) fn retry_policy() -> Box<dyn RetryPolicy> {
         Box::new(DefaultRetryPolicy::new())
     }
-    pub fn speculative_execution_policy() -> Option<Arc<dyn SpeculativeExecutionPolicy>> {
+    pub(crate) fn speculative_execution_policy() -> Option<Arc<dyn SpeculativeExecutionPolicy>> {
         None
     }