dart2js: Run prepareNativeClasses in the program builder.

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;
+  final bool outputContainsNativeClasses;
   /// A map from load id to the list of fragments that need to be loaded.
   final Map<String, List<Fragment>> loadMap;
 
+  /// Additional properties that have to be added to classes.
+  final Map<Class, Map<String, js.Expression>> additionalProperties;
+
   Program(this.fragments,
           this.nativeClasses,
-          this.outputContainsConstantList,
-          this.loadMap);
+          this.additionalProperties,
+          this.loadMap,
+          {this.outputContainsNativeClasses,

[herhut, 2015/01/26 13:50:14]

I am not very keen on this pattern. I assume this is supposed to increase
readability at call sites and I buy that. However, in non-checked mode, this
will fail with strange errors (as null gets propagated). 

[floitsch, 2015/01/26 17:50:40]

I don't think I agree.
Devs should run their code in checked mode at least once. If I add a new call to
this function and I forget an argument it should be detected at first run.
I furthermore believe that the code is read more frequently than it is written.
(In particular calls to this constructor).

+           this.outputContainsConstantList}) {
+    assert(outputContainsNativeClasses != null);
+    assert(outputContainsConstantList != null);
+  }
 
   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 277 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);
 }