dart2js: refactor nsm_emitter.

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) {
-    // Do not generate no such method handlers if there is no class.
-    if (compiler.codegenWorld.directlyInstantiatedClasses.isEmpty) return;
 
-    String noSuchMethodName = namer.publicInstanceMethodNameByArity(
-        Compiler.NO_SUCH_METHOD, Compiler.NO_SUCH_METHOD_ARG_COUNT);
+    Map<String, Selector> jsNames = <String, Selector>{};
 
-    // 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>();
+    Map<String, Selector> computeSelectorsForNsmHandlers() {
+      // Do not generate no such method handlers if there is no class.
+      if (compiler.codegenWorld.directlyInstantiatedClasses.isEmpty) {
+        return jsNames;
+      }
 
-    void addNoSuchMethodHandlers(String ignore, Set<Selector> selectors) {
-      // Cache the object class and type.
-      ClassElement objectClass = compiler.objectClass;
-      DartType objectType = objectClass.rawType;
+      void addNoSuchMethodHandlers(String ignore, Set<Selector> selectors) {
+        TypeMask objectSubclassTypeMask =
+            new TypeMask.subclass(compiler.objectClass, compiler.world);
 
-      for (Selector selector in selectors) {
-        TypeMask mask = selector.mask;
-        if (mask == null) {
-          mask = new TypeMask.subclass(compiler.objectClass, compiler.world);
-        }
+        for (Selector selector in selectors) {
+          TypeMask mask = selector.mask;
+          if (mask == null) mask = objectSubclassTypeMask;
 
-        if (!mask.needsNoSuchMethodHandling(selector, compiler.world)) continue;
-        String jsName = namer.invocationMirrorInternalName(selector);
-        addedJsNames[jsName] = selector;
-        String reflectionName = emitter.getReflectionName(selector, jsName);
-        if (reflectionName != null) {
-          emitter.mangledFieldNames[jsName] = reflectionName;
+          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);
+      return jsNames;
     }
 
-    compiler.codegenWorld.invokedNames.forEach(addNoSuchMethodHandlers);
-    compiler.codegenWorld.invokedGetters.forEach(addNoSuchMethodHandlers);
-    compiler.codegenWorld.invokedSetters.forEach(addNoSuchMethodHandlers);
-
-    // 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);
-
-    jsAst.Expression generateMethod(String jsName, Selector selector) {
+    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);
-      String reflectionName = emitter.getReflectionName(selector, internalName);
-      if (!haveVeryFewNoSuchMemberHandlers &&
-          isTrivialNsmHandler(type, argNames, selector, internalName) &&
-          reflectionName == null) {
-        trivialNsmHandlers.add(selector);
-        return null;
-      }
 
       assert(backend.isInterceptedName(Compiler.NO_SUCH_METHOD));
       jsAst.Expression expression =
           js('''this.#noSuchMethodName(this,
                     #createInvocationMirror(#methodName,
                                             #internalName,
                                             #type,
                                             #arguments,
                                             #namedArguments))''',
-             {'noSuchMethodName': noSuchMethodName,
+             {'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]);
       }
     }
 
+    // Keep track of the JavaScript names we've already added so we
+    // do not introduce duplicates (bad for code size).
+    Map<String, Selector> addedJsNames = computeSelectorsForNsmHandlers();
+
+    // 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];
-      jsAst.Expression method = generateMethod(jsName, selector);
+      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(selector);
       if (method != null) {
         addProperty(jsName, method);
-        String reflectionName = emitter.getReflectionName(selector, jsName);
         if (reflectionName != null) {
           bool accessible = compiler.world.allFunctions.filter(selector).any(
               (Element e) => backend.isAccessibleByReflection(e));
           addProperty('+$reflectionName', js(accessible ? '2' : '0'));
         }
       }
     }
   }
 
   // Identify the noSuchMethod handlers that are so simple that we can
@@ skipping 146 matching lines @@
         diffEncoding.write(short);
       }
       nameCounter++;
     }
 
     // Startup code that loops over the method names and puts handlers on the
     // Object class to catch noSuchMethod invocations.
     ClassElement objectClass = compiler.objectClass;
     jsAst.Expression createInvocationMirror = backend.emitter
         .staticFunctionAccess(backend.getCreateInvocationMirror());
-    String noSuchMethodName = namer.publicInstanceMethodNameByArity(
-        Compiler.NO_SUCH_METHOD, Compiler.NO_SUCH_METHOD_ARG_COUNT);
     var type = 0;
     if (useDiffEncoding) {
       statements.add(js.statement('''{
           var objectClassObject = processedClasses.collected[#objectClass],
               shortNames = #diffEncoding.split(","),
               nameNumber = 0,
               diffEncodedString = shortNames[0],
               calculatedShortNames = [0, 1];    // 0, 1 are args for splice.
           // If we are loading a deferred library the object class will not be in
           // the collectedClasses so objectClassObject is undefined, and we skip
@@ skipping 83 matching lines @@
                 return this.#noSuchMethodName(this,
                     #createInvocationMirror(name, short, type,
                         Array.prototype.slice.call(arguments,
                                                    #sliceOffsetParams),
                                                    []));
               }
           })(#names[j], short, type, #sliceOffsetArguments);
         }
       }''', {
           'sliceOffsetParams': sliceOffsetParams,
-          'noSuchMethodName': noSuchMethodName,
+          'noSuchMethodName': namer.noSuchMethodName,
           'createInvocationMirror': createInvocationMirror,
           'names': minify ? 'shortNames' : 'longNames',
           'sliceOffsetArguments': sliceOffsetArguments}));
 
     return statements;
   }
 }