dart2js: Fix nsm emitter in non-minified mode.

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
@@ skipping 104 matching lines @@
    * decoding the base 88 numbers would overflow JavaScript's puny integers.
    *
    * There are some selectors that have a special calling convention (because
    * they are called with the receiver as the first argument).  They need a
    * slightly different noSuchMethod handler, so we handle these first.
    */
   List<jsAst.Statement> buildTrivialNsmHandlers() {
     List<jsAst.Statement> statements = <jsAst.Statement>[];
     if (trivialNsmHandlers.length == 0) return statements;
 
-    // Find out how many selectors there are with the special calling
-    // convention.
-    bool hasSpecialCallingConvention(Selector selector) {
-        return backend.isInterceptedName(selector.name);
-    }
-    Iterable<Selector> specialSelectors = trivialNsmHandlers.where(
-        (Selector s) => backend.isInterceptedName(s.name));
-    Iterable<Selector> ordinarySelectors = trivialNsmHandlers.where(
-        (Selector s) => !backend.isInterceptedName(s.name));
-
-    // Get the short names (JS names, perhaps minified).
-    Iterable<jsAst.Name> specialShorts =
-        specialSelectors.map(namer.invocationMirrorInternalName);
-    Iterable<jsAst.Name> ordinaryShorts =
-        ordinarySelectors.map(namer.invocationMirrorInternalName);
-
     bool minify = compiler.enableMinification;
     bool useDiffEncoding = minify && trivialNsmHandlers.length > 30;
 
-    jsAst.Expression diffEncoding = new _DiffEncodedListOfNames(
-        [specialShorts, ordinaryShorts],
-        useDiffEncoding);
+    // Find out how many selectors there are with the special calling
+    // convention.
+    Iterable<Selector> specialSelectors = trivialNsmHandlers.where(
+            (Selector s) => backend.isInterceptedName(s.name));
+    Iterable<Selector> ordinarySelectors = trivialNsmHandlers.where(
+            (Selector s) => !backend.isInterceptedName(s.name));
 
+    // Get the short names (JS names, perhaps minified).
+    Iterable<jsAst.Name> specialShorts =
+    specialSelectors.map(namer.invocationMirrorInternalName);

[sigurdm, 2015/06/25 09:15:00]

Indent

[herhut, 2015/06/25 09:21:24]

Done.

+    Iterable<jsAst.Name> ordinaryShorts =
+    ordinarySelectors.map(namer.invocationMirrorInternalName);
+
+    jsAst.Expression sortedShorts;
+    Iterable<String> sortedLongs;
+    if (useDiffEncoding) {
+      sortedShorts = new _DiffEncodedListOfNames(
+          [specialShorts, ordinaryShorts]);
+    } else {
+      Iterable<Selector> sorted =
+          [specialSelectors, ordinarySelectors].expand((e) => (e));

[sigurdm, 2015/06/25 09:15:00]

Maybe call the special selectors intercepted selectors

[herhut, 2015/06/25 09:21:24]

Done.

+      sortedShorts = js.concatenateStrings(
+          js.joinLiterals(
+              sorted.map(namer.invocationMirrorInternalName),
+              js.stringPart(",")),
+          addQuotes: true);
+
+      sortedLongs = sorted.map((selector) =>
+          selector.invocationMirrorMemberName);
+    }
     // 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());
     if (useDiffEncoding) {
       statements.add(js.statement('''{
           var objectClassObject = processedClasses.collected[#objectClass],
               nameSequences = #diffEncoding.split("."),
               shortNames = [];
@@ skipping 27 matching lines @@
                 codes.unshift(${$HASH} + remaining % 88);
               }
               shortNames.push(
                 String.fromCharCode.apply(String, codes));
             }
             if (sequence.length > 1) {
               Array.prototype.push.apply(shortNames, sequence.shift());
             }
           }
         }''', {'objectClass': js.quoteName(namer.className(objectClass)),
-               'diffEncoding': diffEncoding}));
+               'diffEncoding': sortedShorts}));
     } else {
       // No useDiffEncoding version.
-      Iterable<String> longs = trivialNsmHandlers.map((selector) =>
-             selector.invocationMirrorMemberName);
       statements.add(js.statement(
           'var objectClassObject = processedClasses.collected[#objectClass],'
           '    shortNames = #diffEncoding.split(",")',
           {'objectClass': js.quoteName(namer.className(objectClass)),
-           'diffEncoding': diffEncoding}));
+           'diffEncoding': sortedShorts}));
       if (!minify) {
         statements.add(js.statement('var longNames = #longs.split(",")',
-                {'longs': js.string(longs.join(','))}));
+                {'longs': js.string(sortedLongs.join(','))}));
       }
       statements.add(js.statement(
           'if (objectClassObject instanceof Array)'
           '  objectClassObject = objectClassObject[1];'));
     }
 
     dynamic isIntercepted =  // jsAst.Expression or bool.
         specialSelectors.isEmpty
         ? false
         : ordinarySelectors.isEmpty
@@ skipping 58 matching lines @@
 }
 
 /// When pretty printed, this node computes a diff-encoded string for the list
 /// of given names.
 ///
 /// See [buildTrivialNsmHandlers].
 class _DiffEncodedListOfNames extends jsAst.DeferredString
                               implements AstContainer {
   String _cachedValue;
   jsAst.ArrayInitializer ast;
-  bool useDiffEncoding;
 
-  _DiffEncodedListOfNames(Iterable<Iterable<jsAst.Name>> names,
-                          this.useDiffEncoding) {
+  _DiffEncodedListOfNames(Iterable<Iterable<jsAst.Name>> names) {
     // Store the names in ArrayInitializer nodes to make them discoverable
     // by traversals of the ast.
     ast = new jsAst.ArrayInitializer(
         names.map((Iterable i) => new jsAst.ArrayInitializer(i.toList()))
              .toList());
   }
 
   void _computeDiffEncodingForList(Iterable<jsAst.Name> names,
                                    StringBuffer diffEncoding) {
     // Treat string as a number in base 88 with digits in ASCII order from # to
@@ skipping 34 matching lines @@
       return a.compareTo(b);
     }
 
     List<String> shorts =
         names.map((jsAst.Name name) => name.name)
         .toList()
         ..sort(compare);
 
     int previous = 0;
     for (String short in shorts) {
-      if (useDiffEncoding &&
-          short.length <= NsmEmitter.MAX_MINIFIED_LENGTH_FOR_DIFF_ENCODING) {
+      if (short.length <= NsmEmitter.MAX_MINIFIED_LENGTH_FOR_DIFF_ENCODING) {
         int base63 = fromBase88(short);
         int diff = base63 - previous;
         previous = base63;
         String base26Diff = toBase26(diff);
         diffEncoding.write(base26Diff);
       } else {
-        if (useDiffEncoding || diffEncoding.length != 0) {
+        if (diffEncoding.length != 0) {
           diffEncoding.write(',');
         }
         diffEncoding.write(short);
       }
     }
   }
 
   String _computeDiffEncoding() {
     StringBuffer buffer = new StringBuffer();
     for (jsAst.ArrayInitializer list in ast.elements) {
       if (buffer.isNotEmpty) {
-        if (useDiffEncoding) {
-          // Emit period that resets the diff base to zero when we switch to
-          // normal calling convention (this avoids the need to code negative
-          // diffs).
-          buffer.write(".");
-        } else {
-          // Write a separator for the next sequence.
-          buffer.write(",");
-        }
+        // Emit period that resets the diff base to zero when we switch to
+        // normal calling convention (this avoids the need to code negative
+        // diffs).
+        buffer.write(".");
       }
       List<jsAst.Name> names = list.elements;
       _computeDiffEncodingForList(names, buffer);
     }
     return '"${buffer.toString()}"';
   }
 
   String get value {
     if (_cachedValue == null) {
       _cachedValue = _computeDiffEncoding();
     }
 
     return _cachedValue;
   }
 }