Reapply class/method/field minification

sdk/lib/_internal/compiler/implementation/js_backend/emitter_no_eval.dart

 // Copyright (c) 2012, 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 js_backend;
 
 class CodeEmitterNoEvalTask extends CodeEmitterTask {
   CodeEmitterNoEvalTask(Compiler compiler,
                         Namer namer,
                         bool generateSourceMap)
@@ skipping 21 matching lines @@
   }
 
   String get finishIsolateConstructorFunction {
     // We replace the old Isolate function with a new one that initializes
     // all its field with the initial (and often final) value of all globals.
     //
     // We also copy over old values like the prototype, and the
     // isolateProperties themselves.
     return """
 function(oldIsolate) {
-  var isolateProperties = oldIsolate.${namer.ISOLATE_PROPERTIES};
+  var isolateProperties = oldIsolate.${namer.isolatePropertiesName};
   function Isolate() {
     for (var staticName in isolateProperties) {
       if (Object.prototype.hasOwnProperty.call(isolateProperties, staticName)) {
         this[staticName] = isolateProperties[staticName];
       }
     }
     // Use the newly created object as prototype. In Chrome this creates a
     // hidden class for the object and makes sure it is fast to access.
     function ForceEfficientMap() {}
     ForceEfficientMap.prototype = this;
     new ForceEfficientMap;
   }
   Isolate.prototype = oldIsolate.prototype;
   Isolate.prototype.constructor = Isolate;
-  Isolate.${namer.ISOLATE_PROPERTIES} = isolateProperties;
+  Isolate.${namer.isolatePropertiesName} = isolateProperties;
   return Isolate;
 }""";
   }
 
   String get lazyInitializerFunction {
     return """
 function(prototype, staticName, fieldName, getterName, lazyValue, getter) {
 $lazyInitializerLogic
 }""";
   }
@@ skipping 33 matching lines @@
     // d needs both a getter and a setter. Then we produce:
     // - a constructor (directly into the given [buffer]):
     //   function A(b, c, d) { this.b = b, this.c = c, this.d = d; }
     // - getters and setters (stored in the [explicitGettersSetters] list):
     //   get$c : function() { return this.c; }
     //   get$d : function() { return this.d; }
     //   set$d : function(x) { this.d = x; }
     List<String> fields = <String>[];
     visitClassFields(classElement, (Element member,
                                     String name,
+                                    String accessorName,
                                     bool needsGetter,
                                     bool needsSetter,
                                     bool needsCheckedSetter) {
       fields.add(name);
     });
 
     List<String> argumentNames = fields;
     if (fields.length < ($z - $a)) {
       argumentNames = new List<String>(fields.length);
       for (int i = 0; i < fields.length; i++) {
@@ skipping 19 matching lines @@
     if (emitEndingComma) buffer.add(', ');
   }
 
   bool getterAndSetterCanBeImplementedByFieldSpec(Element member,
                                                   String name,
                                                   bool needsGetter,
                                                   bool needsSetter) {
     return false;
   }
 }