#rust-lang

aturon: yea, all past participle across the world lamented over this change

lol

^,-

nox: awake still?

nmatsakis: Ping?

eddyb, nmatsakis: https://botbot.me/mozilla/rust-lang/2018-02-26/...

centril: Added 2 small comments.

nox: hmm, where did you add the comments? I made a branch out of everything which doesn't have your comments in

centril: In the hackmd thing.

centril: In the warnings section.

nox: just there?

Yes.

aight, ill figure out the delta

I’ll go back to my computer once I finish my coffee.

=)

nox: hmm, on "5. `#[field_bound]` is specified on a field which is less visible than the type which contains the field." -- if you do that, you will get a compiler error

things referenced in a where clause can't be less visible than the type for which they are implemented

centril: You said the *field*.

centril: So I'm confused as to what that point means then.

centril: And you can't know if the field *types* (as opposed to the fields themselves) are less private or not than the type in which that field is.

nox: if you have struct Bar<T>(..); pub struct Foo<T> { #[field_bound] field: Bar<T> } then you have a problem

centril: Yes, and the derive can't know that.

centril: So you have a warning and an error for the same problem, and that's confusing.

nox: no, but rustc can

Hence why I think the attribute shouldn't emit any additional warning.

centril: And what you wrote doesn't correspond to '5.' IMO.

Your snippet is about the field *type* being less visible than the type Foo<T>.

Not the *field* being less visible than the type Foo<T>.

note: these warnings are not issued by the derive macro, but by rustc

nox: oh, now I get it

ill rephrase

centril: I understand they are not issued by the derive macro,

centril: but that will still generate 2 things for a single issue,

and that's not helpful, that's confusing, IMO.

struct Bar<T>(T); pub struct Foo<T> { field: Bar<T> } impl<T> Foo<T> where Bar<T>: Clone {} is already a compile error because Bar<T> isn't public,

point 5 seems to say we should emit an additional warning even though there is already an error.

nox: hmm... perhaps then rustc should generate errors when one of 1-7 happens

so the user gets a *better* error message

centril: You mean warning vs error?

centril: Seems fair.

good good

centril: What do you think of my other remark in that section?

nox: not sure I understand it

centril: #[proc_macro_derive(Foo, attributes(…))]

ah, the macro declares that it uses field_bound in attributes

centril: If field_bound isn't in attributes(...), #[field_bound(Foo)] used in a type for which there is #[derive(Foo)] should trigger a warning (or an error).

centril: Yeah. Just reusing existing stuff for better compilation diagnostics.

nox: yeah that seems like it would reduce headaches of users

ill add it

very clever idea

centril: Not the worst? :O

the worst in reverse

Hah.

nox: https://github.com/Centril/rfcs/blob/derive-bou...

nox: mind checking things before i publish?

centril: please add {!crate derivative} to prior art.

derivative (1.0.0) - A set of alternative `derive` attributes for Rust -> https://crates.io/crates/derivative <https://docs.rs/derivative>;

kennytm: interesting, ill take a look =)

centril: https://irccloud.mozilla.com/file/S3KqNoUk/SE21...

centril: Should it list ad-hoc prior art too?

centril: Cause Servo has some of this stuff.

nox: sure

centril: Yes.

nox: Yes?

centril: "— mind checking things before i publish?" "— Shure." That's all. Sorry.

nox: ah =)

centril: Should #[no_bound()] be allowed and be a noop?

centril: Might be useful in macros.

s/macros/generated code/

nox: #[no_bound()] as semantically equivalent to #[no_bound] ?

centril: No, as semantically equivalent to "ignore the bound in this empty list of traits".

oh

nox: hmm... I worry that users who write this directly will think it means the same as #[no_bound]

centril: It can emit a warning,

and the warning be allowable in macros and whatnot.

No?

nox: macros would suppress the warning?

centril: Maybe we should just mention that in unresolved questions?

nox: Sure, i'll do that

centril: No I mean you could do allow(foo) in the macro, when you know you may generate an empty list of traits in no_bound.

nox: right, that's what I meant

Oh ok. :)

centril: Completely unimportant and unrelated:

The `#`being at the end of the line is maddening. :P

nox: sigh :/

Don't amend for that, I don't care. :) Just noticed it that's all.

centril: Currently at 'Drawbacks', so far so good.

neat

centril: https://github.com/Centril/rfcs/blob/derive-bou... <- I think this should also mention the fact that this interpretation of no_bound on a field may not be intuitive,

I misunderstood what you meant at first after all.

=)

centril: LGTM otherwise.

great

nox: I wonder if we should standardize #[derivative(PartialEq="ignore")] as #[ignore(PartialEq)]

centril: Why?

centril: I've never heard of derivative before.

nox: no, but I was thinking of the idiom before I heard about derivative

<#[ignore] T> looks super vague.

ignore(Clone) a bit less,

It seems like a common thing among things like PartialEq, Debug, etc.