Version 0.4.0 - add _code = style to fix #4

Author: idanarye

CHANGELOG.md

@@ -6,6 +6,11 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+## 0.4.0 - 2019-02-19
+### Added
+- `#[default(_code = "...")]` syntax for defaults that cannot be parsed as
+  attributes no matter what.
+
 ## 0.3.0 - 2018-11-02
 ### Changed
 - Require Rust 1.30+.

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "smart-default"
 description = "Rust custom-derive macro for Default with more control on the fields"
-version = "0.3.0"
+version = "0.4.0"
 authors = ["IdanArye <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/idanarye/rust-smart-default"
@@ -13,6 +13,6 @@ keywords = ["default"]
 proc-macro = true
 
 [dependencies]
-syn = {version = "0.15.18", features = ["derive"]}
+syn = {version = "0.15.26", features = ["full"]}
 quote = "0.6.9"
 proc-macro2 = "0.4.20"

README.md

@@ -19,12 +19,14 @@ enum Foo {
         a: i32,
         b: i32,
         #[default(Some(Default::default()))]
-        c: Option<i32>
+        c: Option<i32>,
+        #[default(_code = "vec![1, 2, 3]")]
+        d: Vec<u32>,
     },
     Qux(i32),
 }
 
-assert!(Foo::default() == Foo::Baz { a: 12, b: 0, c: Some(0) });
+assert!(Foo::default() == Foo::Baz { a: 12, b: 0, c: Some(0), d: vec![1, 2, 3] });
 ```
 
 Requires Rust 1.30+ (for non-string values in attributes)

examples/example.rs

@@ -1,4 +1,3 @@
-
 extern crate smart_default;
 
 use smart_default::SmartDefault;
@@ -13,11 +12,13 @@ enum Foo {
         a: i32,
         b: i32,
         #[default(Some(Default::default()))]
-        c: Option<i32>
+        c: Option<i32>,
+        #[default(_code = "vec![1, 2, 3]")]
+        d: Vec<u32>,
     },
     Qux(i32),
 }
 
 fn main() {
-    assert!(Foo::default() == Foo::Baz { a: 12, b: 0, c: Some(0) });
+    assert!(Foo::default() == Foo::Baz { a: 12, b: 0, c: Some(0), d: vec![1, 2, 3] });
 }

src/lib.rs

@@ -40,12 +40,14 @@ use quote::{quote, ToTokens};
 ///         a: i32,
 ///         b: i32,
 ///         #[default(Some(Default::default()))]
-///         c: Option<i32>
+///         c: Option<i32>,
+///         #[default(_code = "vec![1, 2, 3]")]
+///         d: Vec<u32>,
 ///     },
 ///     Qux(i32),
 /// }
 ///
-/// assert!(Foo::default() == Foo::Baz { a: 12, b: 0, c: Some(0) });
+/// assert!(Foo::default() == Foo::Baz { a: 12, b: 0, c: Some(0), d: vec![1, 2, 3] });
 /// # }
 /// ```
 ///
@@ -57,6 +59,8 @@ use quote::{quote, ToTokens};
 /// * `c` is an `Option<i32>`, and it's default is `Some(Default::default())`. Rust cannot (currently)
 ///   parse `#[default = Some(Default::default())]` and therefore we have to use a special syntax:
 ///   `#[default(Some(Default::default))]`
+/// * `d` has the `!` token in it, which cannot (currently) be parsed even with `#[default(...)]`,
+///   so we have to encode it as a string and mark it as `_code = `.
 /// * Documentation for the `impl Default` section is generated automatically, specifying the
 ///   default value returned from `::default()`.
 #[proc_macro_derive(SmartDefault, attributes(default))]
@@ -204,12 +208,29 @@ fn is_default_attr(attr: &syn::Attribute) -> Result<bool, Error> {
     Ok(segment.ident.to_string() == "default")
 }
 
+fn parse_code_hack(meta: &syn::MetaList) -> Result<Option<TokenStream>, Error> {
+    for meta in meta.nested.iter() {
+        if let syn::NestedMeta::Meta(syn::Meta::NameValue(meta)) = meta {
+            if meta.ident != "_code" {
+                continue;
+            }
+            if let syn::Lit::Str(lit) = &meta.lit {
+                use std::str::FromStr;
+                return Ok(Some(TokenStream::from_str(&lit.value())?));
+            }
+        };
+    }
+    Ok(None)
+}
+
 fn find_default_attr_value(attrs: &[syn::Attribute]) -> Result<Option<Option<TokenStream>>, Error> {
     if let Some(default_attr) = find_only(attrs.iter(), |attr| is_default_attr(attr))? {
         match default_attr.parse_meta() {
             Ok(syn::Meta::Word(_)) => Ok(Some(None)),
             Ok(syn::Meta::List(meta)) => {
-                if let Some(field_value) = single_value(meta.nested.iter()) {
+                if let Some (field_value) = parse_code_hack(&meta)? { // #[default(_code = "...")]
+                    Ok(Some(Some(field_value.into_token_stream())))
+                } else if let Some(field_value) = single_value(meta.nested.iter()) { // #[default(...)]
                     Ok(Some(Some(field_value.into_token_stream())))
                 } else {
                     return Err(Error::new(

tests/tests.rs

@@ -136,3 +136,14 @@ fn test_generics_lifetime_parameters() {
 
     assert!(Foo::default() == Foo::Bar(0));
 }
+
+#[test]
+fn test_code_hack() {
+    #[derive(PartialEq, SmartDefault)]
+    struct Foo {
+        #[default(_code = "vec![1, 2, 3]")]
+        v: Vec<u32>,
+    }
+
+    assert!(Foo::default().v == [1, 2, 3]);
+}