dart2js: use model in native emitter.

pkg/compiler/lib/src/js_emitter/model.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart2js.new_js_emitter.model;
 
 import '../js/js.dart' as js show Expression;
 import '../constants/values.dart' show ConstantValue;
 
 import '../deferred_load.dart' show OutputUnit;
 
 import '../common.dart';
 
 class Program {
   final List<Fragment> fragments;
+  final List<Class> nativeClasses;
   final bool outputContainsConstantList;
   /// A map from load id to the list of fragments that need to be loaded.
   final Map<String, List<Fragment>> loadMap;
 
-  Program(this.fragments, this.outputContainsConstantList, this.loadMap);
+  Program(this.fragments,
+          this.nativeClasses,
+          this.outputContainsConstantList,
+          this.loadMap);
 
   bool get isSplit => fragments.length > 1;
   Iterable<Fragment> get deferredFragments => fragments.skip(1);
 }
 
 /**
  * This class represents a JavaScript object that contains static state, like
  * classes or functions.
  */
 class Holder {
@@ skipping 130 matching lines @@
   /// Uses indicate missing information in the model.
   final Element element;
 
   final String name;
   final Holder holder;
   Class _superclass;
   final List<Method> methods;
   final List<InstanceField> fields;
   final bool onlyForRti;
   final bool isDirectlyInstantiated;
+  final bool isNative;
 
   /// Whether the class must be evaluated eagerly.
   bool isEager = false;
 
   Class(this.element,
         this.name, this.holder, this.methods, this.fields,
         {this.onlyForRti,
-         this.isDirectlyInstantiated}) {
+         this.isDirectlyInstantiated,
+         this.isNative}) {
     assert(onlyForRti != null);
     assert(isDirectlyInstantiated != null);
+    assert(isNative != null);
   }
 
   bool get isMixinApplication => false;
   Class get superclass => _superclass;
 
   void setSuperclass(Class superclass) {
     _superclass = superclass;
   }
 
   String get superclassName
       => (superclass == null) ? "" : superclass.name;
   int get superclassHolderIndex
       => (superclass == null) ? 0 : superclass.holder.index;
 }
 
 class MixinApplication extends Class {
   Class _mixinClass;
 
   MixinApplication(Element element,
                    String name, Holder holder,
                    List<Method> methods,
                    List<InstanceField> fields,
                    {bool onlyForRti,
                     bool isDirectlyInstantiated})
       : super(element,
               name, holder, methods, fields,
               onlyForRti: onlyForRti,
-              isDirectlyInstantiated: isDirectlyInstantiated);
+              isDirectlyInstantiated: isDirectlyInstantiated,
+              isNative: false);

[sra1, 2015/01/21 06:27:06]

I believe that you can create a custom element that is simply a mixin
application.

 
   bool get isMixinApplication => true;
   Class get mixinClass => _mixinClass;
 
   void setMixinClass(Class mixinClass) {
     _mixinClass = mixinClass;
   }
 }
 
 class InstanceField {
@@ skipping 46 matching lines @@
   StaticMethod(Element element, String name, this.holder, js.Expression code,
                {bool needsTearOff})
       : super(element, name, code, needsTearOff: needsTearOff);
 }
 
 class StaticStubMethod extends StaticMethod {
   StaticStubMethod(String name, Holder holder, js.Expression code,
                    {bool needsTearOff})
       : super(null, name, holder, code, needsTearOff: needsTearOff);
 }