dart2js: Move parameterStub generation to parameter_stub_generator and add parameter stubs to model.

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';
 import '../js/js.dart' as js;
 
 import '../js_backend/js_backend.dart' show
     Namer,
     JavaScriptBackend,
     JavaScriptConstantCompiler;
 
 import 'js_emitter.dart' show
     ClassStubGenerator,
     CodeEmitterTask,
     InterceptorStubGenerator,
+    ParameterStubGenerator,
     TypeTestGenerator,
     TypeTestProperties;
 
 import '../universe/universe.dart' show Universe;
 import '../deferred_load.dart' show DeferredLoadTask, OutputUnit;
 
 part 'registry.dart';
 
 class ProgramBuilder {
   final Compiler _compiler;
@@ skipping 385 matching lines @@
     js.Expression code = backend.generatedCode[element];
 
     // TODO(kasperl): Figure out under which conditions code is null.
     if (code == null) return null;
 
     bool canTearOff = false;
     String tearOffName;
     bool isClosure = false;
     bool isNotApplyTarget = !element.isFunction || element.isAccessor;
 
-    final bool needsStubs = _methodNeedsStubs(element);
     final bool canBeReflected = _methodCanBeReflected(element);
     final bool canBeApplied = _methodCanBeApplied(element);
     final bool hasSuperAlias = backend.isAliasedSuperMember(element);
 
     if (isNotApplyTarget) {
       canTearOff = false;
     } else {
       if (element.enclosingClass.isClosure) {
         canTearOff = false;
         isClosure = true;
       } else {
         // Careful with operators.
         canTearOff = universe.hasInvokedGetter(element, _compiler.world) ||
             (canBeReflected && !element.isOperator);
         assert(canTearOff ||
                !universe.methodsNeedingSuperGetter.contains(element));
         tearOffName = namer.getterName(element);
       }
     }
 
     if (canTearOff) {
       assert(invariant(element, !element.isGenerativeConstructor));
       assert(invariant(element, !element.isGenerativeConstructorBody));
       assert(invariant(element, !element.isConstructor));
     }
 
     return new InstanceMethod(element, name, code, needsTearOff: canTearOff,
         tearOffName: tearOffName, isClosure: isClosure,
         hasSuperAlias: hasSuperAlias, canBeApplied: canBeApplied,
-        canBeReflected: canBeReflected, needsStubs: needsStubs);
+        canBeReflected: canBeReflected,
+        parameterStubs: _generateParameterStubs(element, canTearOff));
+  }
+
+  List<ParameterStubMethod> _generateParameterStubs(FunctionElement element,
+                                           bool canTearOff) {
+    List<ParameterStubMethod> parameterStubs = <ParameterStubMethod>[];

[herhut, 2015/01/30 10:02:22]

How about 

if (!_methodNeedsStubs) return const <ParameterStubMethod>[];

I think it makes it more obvious that nothing happens unless a method needs
stubs. 

[zarah, 2015/01/30 12:46:39]

Done.

+      if (_methodNeedsStubs(element)) {
+        ParameterStubGenerator generator =
+            new ParameterStubGenerator(_compiler, namer, backend);
+        Map<Selector, js.Expression> parameterStubsForElement =
+            generator.generateParameterStubs(element, canTearOff);
+        parameterStubsForElement.forEach((Selector selector,
+                                          js.Expression code) {
+          String name = namer.invocationName(selector);
+          parameterStubs.add(
+              _buildParameterStubMethod(name, code, selector,
+                                        element: element));
+        });
+      }
+      return parameterStubs;
   }
 
   /// Builds a stub method.
   ///
   /// Stub methods may have an element that can be used for code-size
   /// attribution.
   Method _buildStubMethod(String name, js.Expression code,
                           {Element element}) {
     return new StubMethod(name, code, element: element);
   }
 
+  Method _buildParameterStubMethod(String name, js.Expression code,
+                                   Selector selector,
+                                   {Element element}) {
+    return new ParameterStubMethod(name, code, selector, element: element);
+  }
+
   // 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;
@@ skipping 77 matching lines @@
       return new StaticStubMethod(name, holder, code);
     });
   }
 
   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 StaticDartMethod(element,
                                 name, _registry.registerHolder(holder), code,
                                 needsTearOff: needsTearOff,
                                 tearOffName: tearOffName,
                                 canBeApplied: canBeApplied,
                                 canBeReflected: canBeReflected,
-                                needsStubs: needsStubs);
+                                parameterStubs:
+                                    _generateParameterStubs(element,
+                                                            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;
     }
   }
 }