Allow native classes to mixin behavior from an ordinary Dart class.

Allow native classes to mixin behavior from an ordinary Dart class. 

This is a little bit wonky so let me know if you have great ideas 
on how to make this cleaner. Clearly, we're going to need more test
cases too.

Note that trying to call mixed in methods using super will fail. If
we want that to work we have to introduce aliases for such methods.

R=sra@google.com,ngeoffray@google.com
BUG=

Committed: https://code.google.com/p/dart/source/detail?r=17631

[kasperl, 2013-01-24 11:06:54]

https://codereview.chromium.org/12051056/diff/3001/sdk/lib/_internal/compiler...
File sdk/lib/_internal/compiler/implementation/js_backend/native_emitter.dart
(right):

https://codereview.chromium.org/12051056/diff/3001/sdk/lib/_internal/compiler...
sdk/lib/_internal/compiler/implementation/js_backend/native_emitter.dart:104: if
(method) {
I removed this comment because the newline after the last """ is consumed so the
emitted code looks weird.

[kasperl, 2013-01-24 11:48:51]

An alternative to this (at least for members) is to teach dynamicBind about
mixins. WDYT?

[ngeoffray, 2013-01-24 11:55:53]

LGTM

https://codereview.chromium.org/12051056/diff/5001/sdk/lib/_internal/compiler...
File sdk/lib/_internal/compiler/implementation/js_backend/emitter.dart (right):

https://codereview.chromium.org/12051056/diff/5001/sdk/lib/_internal/compiler...
sdk/lib/_internal/compiler/implementation/js_backend/emitter.dart:753:
visitNativeMixins(classElement, (MixinApplicationElement mixin) {
visitMixinsOfNativeClasses?

https://codereview.chromium.org/12051056/diff/5001/sdk/lib/_internal/compiler...
File sdk/lib/_internal/compiler/implementation/native_handler.dart (right):

https://codereview.chromium.org/12051056/diff/5001/sdk/lib/_internal/compiler...
sdk/lib/_internal/compiler/implementation/native_handler.dart:440: ClassElement
superclass = cls.superclass;
Please add a comment here.

[sra1, 2013-01-24 22:04:56]

On 2013/01/24 11:48:51, kasperl wrote:
> An alternative to this (at least for members) is to teach dynamicBind about
> mixins. WDYT?

I think it is possible to implement mixins via the metadata (which is used by
dynamicBind), but that will complicate the transition to native interceptors
where the trick will no longer work.

The metadata is basically a map from superclass tag to tags of implementing
classes
e.g. ['EventTarget', 'Window|HttpRequest|HTMLDivELement|...']

The method is first looked up via its tag (i.e. the direct native class, which
may be missing), and then via scanning the metadata. Once found, the method is
cached on the native object's prototype.
This structure was chosen so that most DOM Element types can be handled by
having a single list of names rather than a class for all 150 of them just in
case they are in the document.

superclasses are in pre-order traversal so that immediate subclasses occur
before more distant superclasses, and 'Object', if it was there, would be last.

Since the mixin class is the immediate super, it could go first in the list. 
There would need to be two parts:

(1) prepend  ['BogusNativeMixinClass', 'Uint32Array|NodeList|...direct and
indirect']

(2) add a definition of a native class with the tag '*BogusNativeMixinClass' to
hold the mixin methods.

This would not work with a conflict in the lookup order
   class C1 extends ... with M1, M2 {}
   class C2 extends ... with M2, M1 {}   
This could be made to work with 'renaming' one mixin class/tag M1 to M1b,
perhaps by allowing multiple tags.

The current system works because the whole list is scanned, picking up different
methods from different superclasses.  In effect, one flat merged class is
assembled in the native classes immediate prototype.
When we move to native interceptors, the metadata will become a lookup of the
single interceptor, which will break the idea. The lookup will still use
something like the current metadata lookup since we need one hook per isolate,
and want to avoid generating definitions for native classes that exist but have
no distinguishing behaviour.

I think the way forward is to generate the interstitial metadata application
classes algorithmically for regular dart classes and have the native interceptor
classes use that.

[sra1, 2013-01-24 22:05:21]

lgtm