#[builder(default)] now honors struct impls

[TedDriggs]

Addresses issue #61.

[colin-kiegel]

Cool, thanks again you for your initiative. :-)

Here are some thoughts and wishes for this PR:

• As mentioned in this comment, please put the new behaviour behind an opt-in feature-flag, e.g. struct_default?
• It should then be sufficient to have two enum-variants for DefaultExpression.
• You can emit a deprecation note like this. :-)
  I'm thinking about a message roughly like this

warning: the meaning of `#[builder(default)]` on the struct level will change in the
next version (see https://github.com/colin-kiegel/rust-derive-builder/issues/61 for
more details). To squelch this message and adopt the new behavior now, compile
`derive_builder` with `--features "struct_default"`.

• I might want to move the field default_expression from OptionsBuilder to OptionsBuilderMode. The first is dedicated to all shared settings, which are also inherited from struct-level to field-level. The latter captures all the things different for struct/field level. The default attribute will now be in-between somehow. On the one hand it is shared, but on the other hand it is not inherited anymore and has a completely different implementation on the code generation side. I have a tendency to move this field to OptionsBuilderMode right now, but I may have to see the final code here.
• Oh, and I would also appreciate an entry in the Changelog and docs.

Let me know if you need any help/advice.

[colin-kiegel]

one addition: If it's not asking too much I would prefer if the generated code was something like

Foo {
    foo: 42,
    ..::std::default::Default::default()
}

instead of

let __default = ..::std::default::Default::default();
Foo {
    foo: 42,
    bar: __default.bar,
}

PS: It's what people would actually write and has no risk of clashing with other identifiers.

[TedDriggs]

I actually tried to do that, but I couldn't figure out a way for the macro at compile time to figure out which fields would be populated at runtime. I'm almost done with the other changes; will have a new version up soon.

I might want to move the field default_expression from OptionsBuilder to OptionsBuilderMode. The first is dedicated to all shared settings, which are also inherited from struct-level to field-level. The latter captures all the things different for struct/field level. The default attribute will now be in-between somehow. On the one hand it is shared, but on the other hand it is not inherited anymore and has a completely different implementation on the code generation side. I have a tendency to move this field to OptionsBuilderMode right now, but I may have to see the final code here.

I think I understand what you're saying here; once the latest revision passes muster then I'm happy to look at refactoring that.

Oh, and I would also appreciate an entry in the Changelog and docs.

I added a changelog entry; which docs did you want updated? The lib.rs for the main crate?

[TedDriggs]

The deprecation warning is in the correct function - parse_builder_options_word - but it doesn't emit the warning when used at the struct level. Since the struct level is what we want here, that's unfortunate.

I've found the issue and updated the PR. At the moment, this has the side-effect of emitting the warning multiple times; I haven't figured out how to keep it down to 1 yet.

[TedDriggs]

@colin-kiegel I broke the tests and I'm not sure how.

[colin-kiegel]

@TedDriggs The skeptic tests have some issues with cargo cache. Since I activated both cargo cache and skeptic tests in master, I'm sure this failing build is just spurious nonsense and unrelated to this PR. The failing test looks at least similar to this bug in skeptic. I'll look into a workaround - which might involve disabling skeptic tests and/or cargo cache again. :-)

I'll also take a look at your PR this weekend.

[TedDriggs]

Flagging this for closer scrutiny, as it touches on the issue described in #65 (this change is just at the struct level; the field level can be a separate PR).

[TedDriggs]

Possible optimization: Check if all fields are explicitly initialized and avoid allocating the extra object if it won't be used.

[TedDriggs]

The only way I can see to do this is to generate an and-block calling is_some() on every field in the builder, and allowing __default to be Option<#target_ty> instead of #target_ty. I'd then have to call unwrap for every implicitly-instantiated field; I don't know if there's a good way to determine which path is more efficient.

[colin-kiegel]

I think I found a way to generate the code like this:

Foo {
    foo: 42,
    ..#struct_default // <-- only emitted if struct_default is set.
}

This requires to propagate the options a bit differently. I will commit this as soon as I checked everything and added some more tests. :-)

[colin-kiegel]

@TedDriggs I've started some minor refactoring on top of your branch (before your last two commits) - is it ok, if I rebase + push my changes to your branch, too? Alternatively I could just push to a different branch and then maybe let you merge my changes into your PR - especially if you want to continue in parallel. However I'm not yet done. What do you think?

[colin-kiegel]

@TedDriggs Btw. did you delete 2 comments? In my inbox I counted 5 inline-comments, but I count only three in your review - or am I missing something?

[colin-kiegel]

Hm, looks like something went wrong during rebase. I'll rebase again and probably force push.

[colin-kiegel]

Ok, it turns out I actually overlooked something. My current approach does not work, if there is a struct default expression, but no field default expression. It looks like a temporary value is indeed unavoidable - I guess I will change it back, but not force push. :-)

Current

Foo {
        foo: match self.foo {
            Some(value) => value,
            None => /* ... _no_ field default, but we have to return something .... */,
        },
        ../* struct default expression */
}

Previous

let __default = /* struct default expression */;
Foo {
        foo: match self.foo {
            Some(value) => value,
            None => __default.foo,
        },
}