new annotation to identify classes safe for use as mixins

[pq]

More context in #58543.

TL;DR: some classes are intended to be mixed in and it would be great if an annotation could teach the prefer_mixin lint about them.

[pq]

Spitballing names:

• @classMixin?

[bwilkerson]

I think it's worth considering some of the alternatives to creating an annotation before we do so, but if we do create an annotation I suspect that finding a good name will be a challenge. The one listed above seems a bit repetitive:

@classMixin class ChangeNotifier { ... }

We could shorten it

@mixin class ChangeNotifier { ... }

but that seems potentially confusing because there are differences between a class that's used as a mixin and an actual mixin. I'm not coming up with a suggestion I really like at the moment, though I did think of a minor riff on a another suggestion you made:

@mixable class ChangeNotifier { ... }

Still not great.

[pq]

See also dart-lang/language#1529 and dart-lang/language#1643.

Also fyi: @lrhn, @Hixie.

Assuming we're allowing a class to be used as both a class and a mixin, I'm inclined towards @mixable.

[lrhn]

We're currently allowing it, and it would be nice to mark those classes that should really be mixins as exceptions to a rule of not using classes as mixins. (And recommending you change extends to with for them).

How about just using mixin?

const mixin = pragma("analyzer:mixin_class");

@mixin
class JumpingJehoshaphat {
  void jump() {
    print("How high?");
  }
}

The word mixin is only a built-in identifier, not a reserved word, so you can declare variables with that name.

Also, it reads as "I really mean this to be a mixin".

(I'd use a pragma constant for the marker, because then we can create an identical constant inside the platform libraries. Honestly, I'd use pragma constants for all analyzer-understood annotations, instead of inventing new classes.)

[pq]

I believe we've arrived at a near consensus that mixin is the way to go with a leaning towards an annotation over a pragma. IIRC one unresolved issue with consuming this in the SDK is how it would be documented in the APIs and that @lrhn would prefer not to see a mixin annotation show up in the SDK API docs. Does that sound right?

/fyi @jcollins-g

[lrhn]

Not sure what the difference between an annotation and a pragma is, pragmas are annotations.

I'm perfectly fine with annotating platform mixin-classes with @pragma("analyzer:mixin-class") if it keeps the annotation from showing up anywhere. It's only going to be a handful of them, and we don't plant to ever introduce any more.

That would require the analyzer to recognize both that pragma and whichever mixin constant is introduced into package:meta, but that should be doable?

Also, we are currently considering allowing you to write extends Mixin as shorthand for extends Object with Mixin for mixins which can apply to Object. That will allow us to migrate all those "mixin classes" to proper mixin declarations, non-breakingly, and remove the need for the annotation. That won't be any time before 2.16, though, so until then, an annotation can work.

[jcollins-g]

Accidentally submitted comment instead of canceling it. Sorry for the confusion.