dart2js: Fix types in new 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 461 matching lines @@
     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() {
+  Iterable<StaticStubMethod> _generateGetInterceptorMethods() {
     InterceptorStubGenerator stubGenerator =
         new 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) {
@@ skipping 42 matching lines @@
       }
 
       fields.add(new Field(field, name, accessorName,
                            getterFlags, setterFlags,
                            needsCheckedSetter));
     });
 
     return fields;
   }
 
-  Iterable<StaticMethod> _generateOneShotInterceptors() {
+  Iterable<StaticStubMethod> _generateOneShotInterceptors() {
     InterceptorStubGenerator stubGenerator =
         new 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);
     });
   }
 
-  StaticMethod _buildStaticMethod(FunctionElement element) {
+  StaticDartMethod _buildStaticMethod(FunctionElement element) {
     String name = namer.getNameOfMember(element);
     String holder = namer.globalObjectFor(element);
     js.Expression code = backend.generatedCode[element];
 
     final bool isNotApplyTarget = !element.isConstructor && !element.isAccessor;
     final bool needsStubs = _methodNeedsStubs(element);
     final bool canBeApplied = _methodCanBeApplied(element);
     final bool canBeReflected = _methodCanBeReflected(element);
 
     final bool needsTearOff = isNotApplyTarget && (canBeReflected ||
          universe.staticFunctionsNeedingGetter.contains(element));
 
     final String tearOffName =
         needsTearOff ? namer.getStaticClosureName(element) : null;
 
-    return new StaticMethod(element,
-                            name, _registry.registerHolder(holder), code,
-                            needsTearOff: needsTearOff,
-                            tearOffName: tearOffName,
-                            canBeApplied: canBeApplied,
-                            canBeReflected: canBeReflected,
-                            needsStubs: needsStubs);
+    return new StaticDartMethod(element,
+                                name, _registry.registerHolder(holder), code,
+                                needsTearOff: needsTearOff,
+                                tearOffName: tearOffName,
+                                canBeApplied: canBeApplied,
+                                canBeReflected: canBeReflected,
+                                needsStubs: needsStubs);
   }
 
   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;
     }
   }
 }