dart2js: move generation of noSuchMethodStubs into ClassStubGenerator.

pkg/compiler/lib/src/js_emitter/old_emitter/nsm_emitter.dart

 // Copyright (c) 2013, 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.
 
 part of dart2js.js_emitter;
 
 class NsmEmitter extends CodeEmitterHelper {
   final List<Selector> trivialNsmHandlers = <Selector>[];
 
   /// If this is true then we can generate the noSuchMethod handlers at startup
   /// time, instead of them being emitted as part of the Object class.
   bool get generateTrivialNsmHandlers => true;
 
   // If we need fewer than this many noSuchMethod handlers we can save space by
   // just emitting them in JS, rather than emitting the JS needed to generate
   // them at run time.
   static const VERY_FEW_NO_SUCH_METHOD_HANDLERS = 10;
 
   static const MAX_MINIFIED_LENGTH_FOR_DIFF_ENCODING = 4;
 
   void emitNoSuchMethodHandlers(AddPropertyFunction addProperty) {
 
-    void computeSelectorsForNsmHandlers(Map<String, Selector> jsNames) {
-
-      // Do not generate no such method handlers if there is no class.
-      if (compiler.codegenWorld.directlyInstantiatedClasses.isEmpty) return;
-
-      void addNoSuchMethodHandlers(String ignore, Set<Selector> selectors) {
-        // Cache the object class and type.
-        ClassElement objectClass = compiler.objectClass;
-        DartType objectType = objectClass.rawType;
-
-        for (Selector selector in selectors) {
-          TypeMask mask = selector.mask;
-          if (mask == null) {
-            mask = new TypeMask.subclass(compiler.objectClass,
-                                         compiler.world);
-          }
-
-          if (!mask.needsNoSuchMethodHandling(selector, compiler.world)) {
-            continue;
-          }
-          String jsName = namer.invocationMirrorInternalName(selector);
-          jsNames[jsName] = selector;
-        }
-      }
-
-      compiler.codegenWorld.invokedNames.forEach(addNoSuchMethodHandlers);
-      compiler.codegenWorld.invokedGetters.forEach(addNoSuchMethodHandlers);
-      compiler.codegenWorld.invokedSetters.forEach(addNoSuchMethodHandlers);
-    }
-
-    jsAst.Expression generateMethod(Selector selector) {
-      // Values match JSInvocationMirror in js-helper library.
-      int type = selector.invocationMirrorKind;
-      List<String> parameterNames =
-          new List.generate(selector.argumentCount, (i) => '\$$i');
-
-      List<jsAst.Expression> argNames =
-          selector.getOrderedNamedArguments().map((String name) =>
-              js.string(name)).toList();
-
-      String methodName = selector.invocationMirrorMemberName;
-      String internalName = namer.invocationMirrorInternalName(selector);
-
-      assert(backend.isInterceptedName(Compiler.NO_SUCH_METHOD));
-      jsAst.Expression expression =
-          js('''this.#noSuchMethodName(this,
-                    #createInvocationMirror(#methodName,
-                                            #internalName,
-                                            #type,
-                                            #arguments,
-                                            #namedArguments))''',
-             {'noSuchMethodName': namer.noSuchMethodName,
-              'createInvocationMirror':
-                  backend.emitter.staticFunctionAccess(
-                      backend.getCreateInvocationMirror()),
-              'methodName':
-                  js.string(compiler.enableMinification
-                      ? internalName : methodName),
-              'internalName': js.string(internalName),
-              'type': js.number(type),
-              'arguments':
-                  new jsAst.ArrayInitializer(parameterNames.map(js).toList()),
-              'namedArguments': new jsAst.ArrayInitializer(argNames)});
-
-      if (backend.isInterceptedName(selector.name)) {
-        return js(r'function($receiver, #) { return # }',
-                  [parameterNames, expression]);
-      } else {
-        return js(r'function(#) { return # }', [parameterNames, expression]);
-      }
-    }
+    ClassStubGenerator generator =
+        new ClassStubGenerator(compiler, namer, backend);
 
     // Keep track of the JavaScript names we've already added so we
     // do not introduce duplicates (bad for code size).
     Map<String, Selector> addedJsNames = new Map<String, Selector>();
-    computeSelectorsForNsmHandlers(addedJsNames);
+    generator.computeSelectorsForNsmHandlers(addedJsNames);

[floitsch, 2015/02/03 10:48:51]

In the next CL return the map from the generator (and rename it to
`generateSelectorsForNsmHandlers`.

[zarah, 2015/02/03 11:55:18]

Done.

 
     // Set flag used by generateMethod helper below.  If we have very few
     // handlers we use addProperty for them all, rather than try to generate
     // them at runtime.
     bool haveVeryFewNoSuchMemberHandlers =
         (addedJsNames.length < VERY_FEW_NO_SUCH_METHOD_HANDLERS);
     for (String jsName in addedJsNames.keys.toList()..sort()) {
       Selector selector = addedJsNames[jsName];
       String reflectionName = emitter.getReflectionName(selector, jsName);
 
       if (reflectionName != null) {
         emitter.mangledFieldNames[jsName] = reflectionName;
       }
 
       List<jsAst.Expression> argNames =
                selector.getOrderedNamedArguments().map((String name) =>
                    js.string(name)).toList();
       int type = selector.invocationMirrorKind;
       if (!haveVeryFewNoSuchMemberHandlers &&
           isTrivialNsmHandler(type, argNames, selector, jsName) &&
           reflectionName == null) {
         trivialNsmHandlers.add(selector);
       }
 
-      jsAst.Expression method = generateMethod(jsName, selector);
+      jsAst.Expression method = generator.generateStubForNoSuchMethod(selector);
       if (method != null) {
         addProperty(jsName, method);
         if (reflectionName != null) {
           bool accessible = compiler.world.allFunctions.filter(selector).any(
               (Element e) => backend.isAccessibleByReflection(e));
           addProperty('+$reflectionName', js(accessible ? '2' : '0'));
         }
       }
     }
   }
@@ skipping 260 matching lines @@
       }''', {
           'sliceOffsetParams': sliceOffsetParams,
           'noSuchMethodName': noSuchMethodName,
           'createInvocationMirror': createInvocationMirror,
           'names': minify ? 'shortNames' : 'longNames',
           'sliceOffsetArguments': sliceOffsetArguments}));
 
     return statements;
   }
 }