dart2js: start using 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 213 matching lines @@
     });
     return libraries;
   }
 
   // Note that a library-element may have multiple [Library]s, if it is split
   // into multiple output units.
   Library _buildLibrary(LibraryElement library, List<Element> elements) {
     String uri = library.canonicalUri.toString();
 
     List<StaticMethod> statics = elements
-        .where((e) => e is FunctionElement).map(_buildStaticMethod).toList();
-
-    statics.addAll(elements
         .where((e) => e is FunctionElement)
-        .where((e) => universe.staticFunctionsNeedingGetter.contains(e))
-        .map(_buildStaticMethodTearOff));
+        .map(_buildStaticMethod)
+        .toList();
 
     if (library == backend.interceptorsLibrary) {
       statics.addAll(_generateGetInterceptorMethods());
       statics.addAll(_generateOneShotInterceptors());
     }
 
     List<Class> classes = elements
         .where((e) => e is ClassElement)
         .map(_buildClass)
         .toList(growable: false);
@@ skipping 62 matching lines @@
                          name, holder, methods, fields,
                          isDirectlyInstantiated: isInstantiated,
                          onlyForRti: onlyForRti);
     }
     _classes[element] = result;
     return result;
   }
 
   Method _buildMethod(FunctionElement element, js.Expression code) {
     String name = namer.getNameOfInstanceMember(element);
-    return new Method(element, name, code);
+    // TODO(floitsch): compute `needsTearOff`.
+    return new Method(element, name, code, needsTearOff: false);
   }
 
   Method _buildStubMethod(String name, js.Expression code) {
-    return new StubMethod(name, code);
+    // TODO(floitsch): compute `needsTearOff`.
+    return new StubMethod(name, code, needsTearOff: false);
   }
 
   // The getInterceptor methods directly access the prototype of classes.
   // We must evaluate these classes eagerly so that the prototype is
   // accessible.
   void _markEagerInterceptorClasses() {
     Map<String, Set<ClassElement>> specializedGetInterceptors =
         backend.specializedGetInterceptors;
     for (Set<ClassElement> classes in specializedGetInterceptors.values) {
       for (ClassElement element in classes) {
         Class cls = _classes[element];
         if (cls != null) cls.isEager = true;
       }
     }
   }
 
   Iterable<StaticMethod> _generateGetInterceptorMethods() {
     emitterTask.InterceptorStubGenerator stubGenerator =
         new emitterTask.InterceptorStubGenerator(_compiler, namer, backend);
 
     String holderName = namer.globalObjectFor(backend.interceptorsLibrary);
     Holder holder = _registry.registerHolder(holderName);
 
     Map<String, Set<ClassElement>> specializedGetInterceptors =
         backend.specializedGetInterceptors;
     List<String> names = specializedGetInterceptors.keys.toList()..sort();
     return names.map((String name) {
       Set<ClassElement> classes = specializedGetInterceptors[name];
       js.Expression code = stubGenerator.generateGetInterceptorMethod(classes);
-      return new StaticStubMethod(name, holder, code);
+      // TODO(floitsch): compute `needsTearOff`.
+      return new StaticStubMethod(name, holder, code, needsTearOff: false);
     });
   }
 
   bool _fieldNeedsGetter(VariableElement field) {
     assert(field.isField);
     if (_fieldAccessNeverThrows(field)) return false;
     return backend.shouldRetainGetter(field)
         || _compiler.codegenWorld.hasInvokedGetter(field, _compiler.world);
   }
 
@@ skipping 49 matching lines @@
   Iterable<StaticMethod> _generateOneShotInterceptors() {
     emitterTask.InterceptorStubGenerator stubGenerator =
         new emitterTask.InterceptorStubGenerator(_compiler, namer, backend);
 
     String holderName = namer.globalObjectFor(backend.interceptorsLibrary);
     Holder holder = _registry.registerHolder(holderName);
 
     List<String> names = backend.oneShotInterceptors.keys.toList()..sort();
     return names.map((String name) {
       js.Expression code = stubGenerator.generateOneShotInterceptor(name);
-      return new StaticStubMethod(name, holder, code);
+      return new StaticStubMethod(name, holder, code, needsTearOff: false);
     });
   }
 
   StaticMethod _buildStaticMethod(FunctionElement element) {
     String name = namer.getNameOfMember(element);
     String holder = namer.globalObjectFor(element);
     js.Expression code = backend.generatedCode[element];
+    bool needsTearOff =
+        universe.staticFunctionsNeedingGetter.contains(element);
+    // TODO(floitsch): add tear-off name: namer.getStaticClosureName(element).
     return new StaticMethod(element,
-                            name, _registry.registerHolder(holder), code);
-  }
-
-  StaticMethod _buildStaticMethodTearOff(FunctionElement element) {
-    String name = namer.getStaticClosureName(element);
-    String holder = namer.globalObjectFor(element);
-    // TODO(kasperl): This clearly doesn't work yet.
-    js.Expression code = js.string("<<unimplemented>>");
-    return new StaticMethod(element,
-                            name, _registry.registerHolder(holder), code);
+                            name, _registry.registerHolder(holder), code,
+                            needsTearOff: needsTearOff);
   }
 
   void _registerConstants(OutputUnit outputUnit,
                           Iterable<ConstantValue> constantValues) {
     // `constantValues` is null if an outputUnit doesn't contain any constants.
     if (constantValues == null) return;
     for (ConstantValue constantValue in constantValues) {
       _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;
     }
   }
 }