scylla-macros: support renaming the scylla crate

Currently, the macros will only work, if the code using them has
a dependency on the scylla driver, or on the scylla_cql if it's
renamed to scylla.
This is caused by the fact that the paths referring to the scylla
code are hardcoded to use a `scylla` crate.
As a result, if a someone uses the `scylla_cql` crate without
renaming, or renames `scylla_cql` or `scylla` to a name differen
name than `scylla`, the macros will not work.
Similarily, when another crate re-exports the macros, or uses them
in their own macros, it can only work if the crate is used under
the name `scylla` and it additionally re-exports parts of the
`scylla_cql` code that are used in the macro under the same paths.

This patch adds a `crate` helper attribute that allows users to
set the crate name that will export the code that is used in the
macros. All the symbols that are used there are also additionally
exported in a `_macro_internal` module to make re-exporting important
code segments more convenient.

Author: wmitros

scylla-cql/src/lib.rs

@@ -7,3 +7,15 @@ pub use crate::frame::response::cql_to_rust;
 pub use crate::frame::response::cql_to_rust::FromRow;
 
 pub use crate::frame::types::Consistency;
+
+#[doc(hidden)]
+pub mod _macro_internal {
+    pub use crate::frame::response::cql_to_rust::{
+        FromCqlVal, FromCqlValError, FromRow, FromRowError,
+    };
+    pub use crate::frame::response::result::{CqlValue, Row};
+    pub use crate::frame::value::{
+        SerializedResult, SerializedValues, Value, ValueList, ValueTooBig,
+    };
+    pub use crate::macros::*;
+}

scylla-macros/Cargo.toml

@@ -14,3 +14,4 @@ proc-macro = true
 [dependencies]
 syn = "1.0"
 quote = "1.0" 
+proc-macro2 = "1.0"

scylla-macros/src/from_row.rs

@@ -5,6 +5,7 @@ use syn::{spanned::Spanned, DeriveInput};
 /// #[derive(FromRow)] derives FromRow for struct
 pub fn from_row_derive(tokens_input: TokenStream) -> TokenStream {
     let item = syn::parse::<DeriveInput>(tokens_input).expect("No DeriveInput");
+    let path = crate::parser::get_path(&item).expect("No path");
     let struct_fields = crate::parser::parse_named_fields(&item, "FromRow");
 
     let struct_name = &item.ident;
@@ -22,8 +23,8 @@ pub fn from_row_derive(tokens_input: TokenStream) -> TokenStream {
                     .unwrap(); // vals_iter size is checked before this code is reached, so
                                // it is safe to unwrap
 
-                <#field_type as scylla::cql_to_rust::FromCqlVal<::std::option::Option<scylla::frame::response::result::CqlValue>>>::from_cql(col_value)
-                    .map_err(|e| scylla::cql_to_rust::FromRowError::BadCqlVal {
+                <#field_type as #path::_macro_internal::FromCqlVal<::std::option::Option<#path::_macro_internal::CqlValue>>>::from_cql(col_value)
+                    .map_err(|e| #path::_macro_internal::FromRowError::BadCqlVal {
                         err: e,
                         column: col_ix,
                     })?
@@ -33,14 +34,12 @@ pub fn from_row_derive(tokens_input: TokenStream) -> TokenStream {
 
     let fields_count = struct_fields.named.len();
     let generated = quote! {
-        impl #impl_generics scylla::cql_to_rust::FromRow for #struct_name #ty_generics #where_clause {
-            fn from_row(row: scylla::frame::response::result::Row)
-            -> ::std::result::Result<Self, scylla::cql_to_rust::FromRowError> {
-                use scylla::frame::response::result::CqlValue;
-                use scylla::cql_to_rust::{FromCqlVal, FromRow, FromRowError};
+        impl #impl_generics #path::_macro_internal::FromRow for #struct_name #ty_generics #where_clause {
+            fn from_row(row: #path::_macro_internal::Row)
+            -> ::std::result::Result<Self, #path::_macro_internal::FromRowError> {
 
                 if #fields_count != row.columns.len() {
-                    return ::std::result::Result::Err(FromRowError::WrongRowSize {
+                    return ::std::result::Result::Err(#path::_macro_internal::FromRowError::WrongRowSize {
                         expected: #fields_count,
                         actual: row.columns.len(),
                     });

scylla-macros/src/from_user_type.rs

@@ -5,6 +5,7 @@ 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) -> TokenStream {
     let item = syn::parse::<DeriveInput>(tokens_input).expect("No DeriveInput");
+    let path = crate::parser::get_path(&item).expect("Couldn't get path to the scylla crate");
     let struct_fields = crate::parser::parse_named_fields(&item, "FromUserType");
 
     let struct_name = &item.ident;
@@ -16,7 +17,7 @@ pub fn from_user_type_derive(tokens_input: TokenStream) -> TokenStream {
         let field_type = &field.ty;
 
         quote_spanned! {field.span() =>
-            #field_name: <#field_type as scylla::cql_to_rust::FromCqlVal<::std::option::Option<scylla::frame::response::result::CqlValue>>>::from_cql(
+            #field_name: <#field_type as #path::_macro_internal::FromCqlVal<::std::option::Option<#path::_macro_internal::CqlValue>>>::from_cql(
                 {
                     let received_field_name: ::std::option::Option<&::std::string::String> = fields_iter
                         .peek()
@@ -43,17 +44,14 @@ pub fn from_user_type_derive(tokens_input: TokenStream) -> TokenStream {
     });
 
     let generated = quote! {
-        impl #impl_generics scylla::cql_to_rust::FromCqlVal<scylla::frame::response::result::CqlValue> for #struct_name #ty_generics #where_clause {
-            fn from_cql(cql_val: scylla::frame::response::result::CqlValue)
-            -> ::std::result::Result<Self, scylla::cql_to_rust::FromCqlValError> {
-                use ::std::collections::BTreeMap;
-                use scylla::cql_to_rust::{FromCqlVal, FromCqlValError};
-                use scylla::frame::response::result::CqlValue;
+        impl #impl_generics #path::_macro_internal::FromCqlVal<#path::_macro_internal::CqlValue> for #struct_name #ty_generics #where_clause {
+            fn from_cql(cql_val: #path::_macro_internal::CqlValue)
+            -> Result<Self, #path::_macro_internal::FromCqlValError> {
 
                 // Interpret CqlValue as CQlValue::UserDefinedType
                 let mut fields_iter = match cql_val {
-                    CqlValue::UserDefinedType{fields, ..} => fields.into_iter().peekable(),
-                    _ => return std::result::Result::Err(FromCqlValError::BadCqlType),
+                    #path::_macro_internal::CqlValue::UserDefinedType{fields, ..} => fields.into_iter().peekable(),
+                    _ => return ::std::result::Result::Err(#path::_macro_internal::FromCqlValError::BadCqlType),
                 };
 
                 // Parse struct using values from fields
@@ -63,10 +61,10 @@ pub fn from_user_type_derive(tokens_input: TokenStream) -> TokenStream {
 
                 // There should be no unused fields when reading user defined type
                 if fields_iter.next().is_some() {
-                    return std::result::Result::Err(FromCqlValError::BadCqlType);
+                    return ::std::result::Result::Err(#path::_macro_internal::FromCqlValError::BadCqlType);
                 }
 
-                return std::result::Result::Ok(result);
+                return ::std::result::Result::Ok(result);
             }
         }
     };

scylla-macros/src/into_user_type.rs

@@ -5,6 +5,7 @@ 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) -> TokenStream {
     let item = syn::parse::<DeriveInput>(tokens_input).expect("No DeriveInput");
+    let path = crate::parser::get_path(&item).expect("No path");
     let struct_fields = crate::parser::parse_named_fields(&item, "IntoUserType");
 
     let struct_name = &item.ident;
@@ -14,17 +15,14 @@ pub fn into_user_type_derive(tokens_input: TokenStream) -> TokenStream {
         let field_name = &field.ident;
 
         quote_spanned! {field.span() =>
-            <_ as scylla::frame::value::Value>::serialize(&self.#field_name, buf) ?;
+            <_ as #path::_macro_internal::Value>::serialize(&self.#field_name, buf) ?;
         }
     });
 
     let generated = quote! {
-        impl #impl_generics scylla::frame::value::Value for #struct_name #ty_generics #where_clause {
-            fn serialize(&self, buf: &mut ::std::vec::Vec<::core::primitive::u8>) -> ::std::result::Result<(), scylla::frame::value::ValueTooBig> {
-                use scylla::frame::value::{Value, ValueTooBig};
-                use scylla::macros::BufMut;
-                use ::std::convert::TryInto;
-
+        impl #impl_generics #path::_macro_internal::Value for #struct_name #ty_generics #where_clause {
+            fn serialize(&self, buf: &mut ::std::vec::Vec<::core::primitive::u8>) -> ::std::result::Result<(), #path::_macro_internal::ValueTooBig> {
+                use #path::_macro_internal::BufMut;
 
                 // Reserve space to put serialized size in
                 let total_size_index: ::core::primitive::usize = buf.len();
@@ -37,7 +35,7 @@ pub fn into_user_type_derive(tokens_input: TokenStream) -> TokenStream {
 
                 // Put serialized size in its place
                 let total_size : ::core::primitive::usize = buf.len() - len_before_serialize;
-                let total_size_i32: ::core::primitive::i32 = total_size.try_into().map_err(|_| ValueTooBig) ?;
+                let total_size_i32: ::core::primitive::i32 = total_size.try_into().map_err(|_| #path::_macro_internal::ValueTooBig) ?;
                 buf[total_size_index..(total_size_index+4)].copy_from_slice(&total_size_i32.to_be_bytes()[..]);
 
                 ::std::result::Result::Ok(())

scylla-macros/src/lib.rs

@@ -8,28 +8,28 @@ mod value_list;
 
 /// #[derive(FromRow)] derives FromRow for struct
 /// Works only on simple structs without generics etc
-#[proc_macro_derive(FromRow)]
+#[proc_macro_derive(FromRow, attributes(scylla_macros))]
 pub fn from_row_derive(tokens_input: TokenStream) -> TokenStream {
     from_row::from_row_derive(tokens_input)
 }
 
 /// #[derive(FromUserType)] allows to parse a struct as User Defined Type
 /// Works only on simple structs without generics etc
-#[proc_macro_derive(FromUserType)]
+#[proc_macro_derive(FromUserType, attributes(scylla_macros))]
 pub fn from_user_type_derive(tokens_input: TokenStream) -> TokenStream {
     from_user_type::from_user_type_derive(tokens_input)
 }
 
 /// #[derive(IntoUserType)] allows to parse a struct as User Defined Type
 /// Works only on simple structs without generics etc
-#[proc_macro_derive(IntoUserType)]
+#[proc_macro_derive(IntoUserType, attributes(scylla_macros))]
 pub fn into_user_type_derive(tokens_input: TokenStream) -> TokenStream {
     into_user_type::into_user_type_derive(tokens_input)
 }
 
 /// #[derive(ValueList)] derives ValueList for struct
 /// Works only on simple structs without generics etc
-#[proc_macro_derive(ValueList)]
+#[proc_macro_derive(ValueList, attributes(scylla_macros))]
 pub fn value_list_derive(tokens_input: TokenStream) -> TokenStream {
     value_list::value_list_derive(tokens_input)
 }

scylla-macros/src/parser.rs

@@ -1,4 +1,5 @@
 use syn::{Data, DeriveInput, Fields, FieldsNamed};
+use syn::{Lit, Meta};
 
 /// Parses the tokens_input to a DeriveInput and returns the struct name from which it derives and
 /// the named fields
@@ -17,3 +18,43 @@ pub(crate) fn parse_named_fields<'a>(
         _ => panic!("derive({}) works only on structs!", current_derive),
     }
 }
+
+pub(crate) fn get_path(input: &DeriveInput) -> Result<proc_macro2::TokenStream, syn::Error> {
+    let mut this_path = quote::quote!(scylla);
+    for attr in input.attrs.iter() {
+        if !attr.path.is_ident("scylla_macros") {
+            continue;
+        }
+        match attr.parse_meta() {
+            Ok(Meta::List(meta_list)) => {
+                for nested_meta in meta_list.nested.iter() {
+                    if let syn::NestedMeta::Meta(Meta::NameValue(meta_name_value)) = nested_meta {
+                        if !meta_name_value.path.is_ident("crate") {
+                            continue;
+                        }
+                        if let Lit::Str(lit_str) = &meta_name_value.lit {
+                            let path_val =
+                                &lit_str.value().parse::<proc_macro2::TokenStream>().unwrap();
+                            this_path = quote::quote!(#path_val);
+                        } else {
+                            return Err(syn::Error::new_spanned(
+                                &meta_name_value.lit,
+                                "the `crate` attribute should be a string literal",
+                            ));
+                        }
+                    }
+                }
+            }
+            Ok(other) => {
+                return Err(syn::Error::new_spanned(
+                    other,
+                    "unexpected scylla_macros helper attribute",
+                ));
+            }
+            Err(err) => {
+                return Err(err);
+            }
+        }
+    }
+    Ok(this_path)
+}

scylla-macros/src/value_list.rs

@@ -6,6 +6,7 @@ use syn::DeriveInput;
 /// which can be fed to the query directly.
 pub fn value_list_derive(tokens_input: TokenStream) -> TokenStream {
     let item = syn::parse::<DeriveInput>(tokens_input).expect("No DeriveInput");
+    let path = crate::parser::get_path(&item).expect("No path");
     let struct_fields = crate::parser::parse_named_fields(&item, "ValueList");
 
     let struct_name = &item.ident;
@@ -14,9 +15,9 @@ pub fn value_list_derive(tokens_input: TokenStream) -> TokenStream {
     let values_len = struct_fields.named.len();
     let field_name = struct_fields.named.iter().map(|field| &field.ident);
     let generated = quote! {
-        impl #impl_generics scylla::frame::value::ValueList for #struct_name #ty_generics #where_clause {
-            fn serialized(&self) -> scylla::frame::value::SerializedResult {
-                let mut result = scylla::frame::value::SerializedValues::with_capacity(#values_len);
+        impl #impl_generics #path::_macro_internal::ValueList for #struct_name #ty_generics #where_clause {
+            fn serialized(&self) -> #path::_macro_internal::SerializedResult {
+                let mut result = #path::_macro_internal::SerializedValues::with_capacity(#values_len);
                 #(
                     result.add_value(&self.#field_name)?;
                 )*

scylla/src/lib.rs

@@ -93,6 +93,11 @@
 
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 
+#[doc(hidden)]
+pub mod _macro_internal {
+    pub use scylla_cql::_macro_internal::*;
+}
+
 pub use scylla_cql::frame;
 pub use scylla_cql::macros::{self, *};