dart2js: Use is-checks from the model in the old emitter.

pkg/compiler/lib/src/js_emitter/program_builder.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.js_emitter.program_builder;
 
 import 'js_emitter.dart' show computeMixinClass;
 import 'model.dart';
 
 import '../common.dart';
@@ skipping 18 matching lines @@
 
 part 'registry.dart';
 
 class ProgramBuilder {
   final Compiler _compiler;
   final Namer namer;
   final emitterTask.CodeEmitterTask _task;
 
   final Registry _registry;
 
+  /// True if the program should store function types in the metadata.
+  bool _storeFunctionTypesInMetadata = false;
+
   ProgramBuilder(Compiler compiler,
                  this.namer,
                  this._task)
       : this._compiler = compiler,
         this._registry = new Registry(compiler);
 
   JavaScriptBackend get backend => _compiler.backend;
   Universe get universe => _compiler.codegenWorld;
 
   /// Mapping from [ClassElement] to constructed [Class]. We need this to
   /// update the superclass in the [Class].
   final Map<ClassElement, Class> _classes = <ClassElement, Class>{};
 
   /// Mapping from [OutputUnit] to constructed [Fragment]. We need this to
   /// generate the deferredLoadingMap (to know which hunks to load).
   final Map<OutputUnit, Fragment> _outputs = <OutputUnit, Fragment>{};
 
   /// Mapping from [ConstantValue] to constructed [Constant]. We need this to
   /// update field-initializers to point to the ConstantModel.
   final Map<ConstantValue, Constant> _constants = <ConstantValue, Constant>{};
 
-  Program buildProgram() {
+  Program buildProgram({bool storeFunctionTypesInMetadata: false}) {
+    this._storeFunctionTypesInMetadata = storeFunctionTypesInMetadata;
     // Note: In rare cases (mostly tests) output units can be empty. This
     // happens when the deferred code is dead-code eliminated but we still need
     // to check that the library has been loaded.
     _compiler.deferredLoadTask.allOutputUnits.forEach(
         _registry.registerOutputUnit);
     _task.outputClassLists.forEach(_registry.registerElements);
     _task.outputStaticLists.forEach(_registry.registerElements);
     _task.outputConstantLists.forEach(_registerConstants);
     _task.outputStaticNonFinalFieldLists.forEach(_registry.registerElements);
 
@@ skipping 206 matching lines @@
 
     // MixinApplications run through the members of their mixin. Here, we are
     // only interested in direct members.
     if (!element.isMixinApplication) {
       implementation.forEachMember(visitMember, includeBackendMembers: true);
     }
 
     emitterTask.TypeTestGenerator generator =
         new emitterTask.TypeTestGenerator(_compiler, _task, namer);
     emitterTask.TypeTestProperties typeTests =
-        generator.generateIsTests(element);
+        generator.generateIsTests(
+            element,
+            storeFunctionTypeInMetadata: _storeFunctionTypesInMetadata);
 
-    // At this point a mixin application must not have any methods or fields.
-    // Type-tests might be added to mixin applications, too.
-    assert(!element.isMixinApplication || methods.isEmpty);
-    assert(!element.isMixinApplication || fields.isEmpty);
-
-    // TODO(floitsch): we should not add the code here, but have a list of
-    // is/as classes in the Class object.
-    // The individual emitters should then call the type test generator to
-    // generate the code.
+    List<StubMethod> isChecks = <StubMethod>[];
     typeTests.properties.forEach((String name, js.Node code) {
-      methods.add(_buildStubMethod(name, code));
+      isChecks.add(_buildStubMethod(name, code));
     });
 
     String name = namer.getNameOfClass(element);
     String holderName = namer.globalObjectFor(element);
     Holder holder = _registry.registerHolder(holderName);
     bool onlyForRti = _task.typeTestRegistry.rtiNeededClasses.contains(element);
     bool isInstantiated =
         _compiler.codegenWorld.directlyInstantiatedClasses.contains(element);
 
     Class result;
     if (element.isMixinApplication && !onlyForRti) {
       assert(!element.isNative);
+      assert(methods.isEmpty);
+      assert(fields.isEmpty);
+
       result = new MixinApplication(element,
-                                    name, holder, methods, fields,
+                                    name, holder, isChecks,
+                                    typeTests.functionTypeIndex,
                                     isDirectlyInstantiated: isInstantiated,
                                     onlyForRti: onlyForRti);
     } else {
       result = new Class(element,
-                         name, holder, methods, fields,
+                         name, holder, methods, fields, isChecks,
+                         typeTests.functionTypeIndex,
                          isDirectlyInstantiated: isInstantiated,
                          onlyForRti: onlyForRti,
                          isNative: element.isNative);
     }
     _classes[element] = result;
     return result;
   }
 
   Method _buildMethod(FunctionElement element, js.Expression code) {
     String name = namer.getNameOfInstanceMember(element);
@@ skipping 128 matching lines @@
       _registry.registerConstant(outputUnit, constantValue);
       assert(!_constants.containsKey(constantValue));
       String name = namer.constantName(constantValue);
       String constantObject = namer.globalObjectForConstant(constantValue);
       Holder holder = _registry.registerHolder(constantObject);
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 }