Reapply class/method/field minification

sdk/lib/_internal/compiler/implementation/js_backend/emitter.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;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 74 matching lines @@
     return constantEmitter.reference(value);
   }
 
   js.Expression constantInitializerExpression(Constant value) {
     return constantEmitter.initializationExpression(value);
   }
 
   String get name => 'CodeEmitter';
 
   String get defineClassName
-      => '${namer.ISOLATE}.\$defineClass';
+      => '${namer.isolateName}.\$defineClass';
   String get currentGenerateAccessorName
       => '${namer.CURRENT_ISOLATE}.\$generateAccessor';
   String get generateAccessorHolder
       => '$isolatePropertiesName.\$generateAccessor';
   String get finishClassesName
-      => '${namer.ISOLATE}.\$finishClasses';
+      => '${namer.isolateName}.\$finishClasses';
   String get finishIsolateConstructorName
-      => '${namer.ISOLATE}.\$finishIsolateConstructor';
+      => '${namer.isolateName}.\$finishIsolateConstructor';
   String get pendingClassesName
-      => '${namer.ISOLATE}.\$pendingClasses';
+      => '${namer.isolateName}.\$pendingClasses';
   String get isolatePropertiesName
-      => '${namer.ISOLATE}.${namer.ISOLATE_PROPERTIES}';
+      => '${namer.isolateName}.${namer.isolatePropertiesName}';
   String get supportsProtoName
       => 'supportsProto';
   String get lazyInitializerName
-      => '${namer.ISOLATE}.\$lazy';
+      => '${namer.isolateName}.\$lazy';
 
-  final String GETTER_SUFFIX = "?";
-  final String SETTER_SUFFIX = "!";
-  final String GETTER_SETTER_SUFFIX = "=";
+  // Property name suffixes.  If the accessors are renaming then the format
+  // is <accessorName>:<fieldName><suffix>.  We use the suffix to know whether
+  // to look for the ':' separator in order to avoid doing the indexOf operation
+  // on every single property (they are quite rare).  None of these characters
+  // are legal in an identifier and they are related by bit patterns.
+  // setter          <          0x3c
+  // both            =          0x3d
+  // getter          >          0x3e
+  // renaming setter |          0x7c
+  // renaming both   }          0x7d
+  // renaming getter ~          0x7e
+  const SUFFIX_MASK = 0x3f;
+  const FIRST_SUFFIX_CODE = 0x3c;
+  const SETTER_CODE = 0x3c;
+  const GETTER_SETTER_CODE = 0x3d;
+  const GETTER_CODE = 0x3e;
+  const RENAMING_FLAG = 0x40;
+  String needsGetterCode(String variable) => '($variable & 3) > 0';
+  String needsSetterCode(String variable) => '($variable & 2) == 0';
+  String isRenaming(String variable) => '($variable & $RENAMING_FLAG) != 0';
 
   String get generateAccessorFunction {
     return """
 function generateAccessor(field, prototype) {
   var len = field.length;
-  var lastChar = field[len - 1];
-  var needsGetter = lastChar == '$GETTER_SUFFIX' || lastChar == '$GETTER_SETTER_SUFFIX';
-  var needsSetter = lastChar == '$SETTER_SUFFIX' || lastChar == '$GETTER_SETTER_SUFFIX';
-  if (needsGetter || needsSetter) field = field.substring(0, len - 1);
-  if (needsGetter) {
-    var getterString = "return this." + field + ";";
-"""
-  /* The supportsProtoCheck below depends on the getter/setter convention.
-         When changing here, update the protoCheck too. */
-  """
-      prototype["get\$" + field] = new Function(getterString);
+  var lastCharCode = field.charCodeAt(len - 1);
+  var needsAccessor = (lastCharCode & $SUFFIX_MASK) >= $FIRST_SUFFIX_CODE;
+  if (needsAccessor) {
+    var needsGetter = ${needsGetterCode('lastCharCode')};
+    var needsSetter = ${needsSetterCode('lastCharCode')};
+    var renaming = ${isRenaming('lastCharCode')};
+    var accessorName = field = field.substring(0, len - 1);
+    if (renaming) {
+      var divider = field.indexOf(":");
+      accessorName = field.substring(0, divider);
+      field = field.substring(divider + 1);
+    }
+    if (needsGetter) {
+      var getterString = "return this." + field + ";";
+      prototype["get\$" + accessorName] = new Function(getterString);
     }
     if (needsSetter) {
       var setterString = "this." + field + " = v;";
-      prototype["set\$" + field] = new Function("v", setterString);
+      prototype["set\$" + accessorName] = new Function("v", setterString);
     }
-    return field;
-  }""";
+  }
+  return field;
+}""";
   }
 
   String get defineClassFunction {
     // First the class name, then the field names in an array and the members
     // (inside an Object literal).
     // The caller can also pass in the constructor as a function if needed.
     //
     // Example:
     // defineClass("A", ["x", "y"], {
     //  foo$1: function(y) {
@@ skipping 37 matching lines @@
     // (http://my.opera.com/desktopteam/blog/2012/07/20/more-12-01-fixes).
     // If the browser does not support __proto__ we need to instantiate an
     // object with the correct (internal) prototype set up correctly, and then
     // copy the members.
 
     return '''
 var $supportsProtoName = false;
 var tmp = $defineClassName('c', ['f?'], {}).prototype;
 if (tmp.__proto__) {
   tmp.__proto__ = {};
-  if (typeof tmp.get\$f !== "undefined") $supportsProtoName = true;
+  if (typeof tmp.get\$f !== 'undefined') $supportsProtoName = true;
 }
 ''';
   }
 
   String get finishClassesFunction {
     // 'defineClass' does not require the classes to be constructed in order.
     // Classes are initially just stored in the 'pendingClasses' field.
     // 'finishClasses' takes all pending classes and sets up the prototype.
     // Once set up, the constructors prototype field satisfy:
     //  - it contains all (local) members.
@@ skipping 51 matching lines @@
           newPrototype[member] = prototype[member];
         }
       }
     }
   }
   for (var cls in pendingClasses) finishClass(cls);
 }''';
   }
 
   String get finishIsolateConstructorFunction {
-    String isolate = namer.ISOLATE;
+    String isolate = namer.isolateName;
     // 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.
     // This has two advantages:
     //   1. the properties are in the object itself (thus avoiding to go through
     //      the prototype when looking up globals.
     //   2. a new isolate goes through a (usually well optimized) constructor
     //      function of the form: "function() { this.x = ...; this.y = ...; }".
     //
     // Example: If [isolateProperties] is an object containing: x = 3 and
     // A = function A() { /* constructor of class A. */ }, then we generate:
     // str = "{
     //   var isolateProperties = Isolate.$isolateProperties;
     //   this.x = isolateProperties.x;
     //   this.A = isolateProperties.A;
     // }";
     // which is then dynamically evaluated:
     //   var newIsolate = new Function(str);
     //
     // 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};
   var isolatePrototype = oldIsolate.prototype;
   var str = "{\\n";
-  str += "var properties = $isolate.${namer.ISOLATE_PROPERTIES};\\n";
+  str += "var properties = $isolate.${namer.isolatePropertiesName};\\n";
   for (var staticName in isolateProperties) {
     if (Object.prototype.hasOwnProperty.call(isolateProperties, staticName)) {
       str += "this." + staticName + "= properties." + staticName + ";\\n";
     }
   }
   str += "}\\n";
   var newIsolate = new Function(str);
   newIsolate.prototype = isolatePrototype;
   isolatePrototype.constructor = newIsolate;
-  newIsolate.${namer.ISOLATE_PROPERTIES} = isolateProperties;
+  newIsolate.${namer.isolatePropertiesName} = isolateProperties;
   return newIsolate;
 }""";
   }
 
   String get lazyInitializerFunction {
     String isolate = namer.CURRENT_ISOLATE;
     return """
 function(prototype, staticName, fieldName, getterName, lazyValue) {
   var getter = new Function("{ return $isolate." + fieldName + ";}");
 $lazyInitializerLogic
@@ skipping 50 matching lines @@
     }
   }
 
   void emitFinishIsolateConstructor(CodeBuffer buffer) {
     String name = finishIsolateConstructorName;
     String value = finishIsolateConstructorFunction;
     buffer.add("$name = $value;\n");
   }
 
   void emitFinishIsolateConstructorInvocation(CodeBuffer buffer) {
-    String isolate = namer.ISOLATE;
+    String isolate = namer.isolateName;
     buffer.add("$isolate = $finishIsolateConstructorName($isolate);\n");
   }
 
   /**
    * Generate stubs to handle invocation of methods with optional
    * arguments.
    *
    * A method like [: foo([x]) :] may be invoked by the following
    * calls: [: foo(), foo(1), foo(x: 1) :]. See the sources of this
    * function for detailed examples.
@@ skipping 135 matching lines @@
     // (3) foo$3$d(a, b, d) => foo$4$c$d(a, b, null, d);
     // (4) No stub generated, call is direct.
     // (5) No stub generated, call is direct.
 
     // Keep a cache of which stubs have already been generated, to
     // avoid duplicates. Note that even if selectors are
     // canonicalized, we would still need this cache: a typed selector
     // on A and a typed selector on B could yield the same stub.
     Set<String> generatedStubNames = new Set<String>();
     if (compiler.enabledFunctionApply
-        && member.name == Namer.CLOSURE_INVOCATION_NAME) {
+        && member.name == namer.closureInvocationSelector) {
       // If [Function.apply] is called, we pessimistically compile all
       // possible stubs for this closure.
       FunctionSignature signature = member.computeSignature(compiler);
       Set<Selector> selectors = signature.optionalParametersAreNamed
           ? computeNamedSelectors(signature, member)
           : computeOptionalSelectors(signature, member);
       for (Selector selector in selectors) {
         addParameterStub(
             member, selector, defineInstanceMember, generatedStubNames);
       }
@@ skipping 74 matching lines @@
 
   bool instanceFieldNeedsSetter(Element member) {
     assert(member.isField());
     return (!member.modifiers.isFinalOrConst())
         && compiler.codegenWorld.hasInvokedSetter(member, compiler);
   }
 
   String compiledFieldName(Element member) {
     assert(member.isField());
     return member.isNative()
-        ? member.name.slowToString()
+        ? member.nativeName()
         : namer.getName(member);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void addInstanceMember(Element member,
                          DefineMemberFunction defineInstanceMember) {
@@ skipping 83 matching lines @@
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void visitClassFields(ClassElement classElement,
                         void addField(Element member,
                                       String name,
+                                      String accessorName,
                                       bool needsGetter,
                                       bool needsSetter,
                                       bool needsCheckedSetter)) {
     assert(invariant(classElement, classElement.isDeclaration));
     // If the class is never instantiated we still need to set it up for
     // inheritance purposes, but we can simplify its JavaScript constructor.
     bool isInstantiated =
         compiler.codegenWorld.instantiatedClasses.contains(classElement);
 
     void visitField(ClassElement enclosingClass, Element member) {
@@ skipping 29 matching lines @@
             : accessorName;
         bool needsCheckedSetter = false;
         if (needsSetter && compiler.enableTypeAssertions
             && canGenerateCheckedSetter(member)) {
           needsCheckedSetter = true;
           needsSetter = false;
         }
         // Getters and setters with suffixes will be generated dynamically.
         addField(member,
                  fieldName,
+                 accessorName,
                  needsGetter,
                  needsSetter,
                  needsCheckedSetter);
       }
     }
 
     // If a class is not instantiated then we add the field just so we can
     // generate the field getter/setter dynamically. Since this is only
     // allowed on fields that are in [classElement] we don't need to visit
     // superclasses for non-instantiated classes.
     classElement.implementation.forEachInstanceField(
         visitField,
         includeBackendMembers: true,
         includeSuperMembers: isInstantiated && !classElement.isNative());
   }
 
-  void generateGetter(Element member, String fieldName, CodeBuffer buffer) {
-    String getterName = namer.getterName(member.getLibrary(), member.name);
-    buffer.add("$getterName: function() { return this.$fieldName; }");
-  }
-
-  void generateSetter(Element member, String fieldName, CodeBuffer buffer) {
-    String setterName = namer.setterName(member.getLibrary(), member.name);
-    buffer.add("$setterName: function(v) { this.$fieldName = v; }");
-  }
-
   bool canGenerateCheckedSetter(Element member) {
     DartType type = member.computeType(compiler);
     if (type.element.isTypeVariable()
         || type.element == compiler.dynamicClass
         || type.element == compiler.objectClass) {
       // TODO(ngeoffray): Support type checks on type parameters.
       return false;
     }
     return true;
   }
 
   void generateCheckedSetter(Element member,
                              String fieldName,
+                             String accessorName,
                              CodeBuffer buffer) {
     assert(canGenerateCheckedSetter(member));
     DartType type = member.computeType(compiler);
     SourceString helper = compiler.backend.getCheckedModeHelper(type);
     FunctionElement helperElement = compiler.findHelper(helper);
     String helperName = namer.isolateAccess(helperElement);
     String additionalArgument = '';
     if (helperElement.computeSignature(compiler).parameterCount != 1) {
       additionalArgument = ", '${namer.operatorIs(type.element)}'";
     }
-    String setterName = namer.setterName(member.getLibrary(), member.name);
+    String setterName = namer.setterNameFromAccessorName(accessorName);
     buffer.add("$setterName: function(v) { "
         "this.$fieldName = $helperName(v$additionalArgument); }");
   }
 
   void emitClassConstructor(ClassElement classElement, CodeBuffer buffer) {
     /* Do nothing. */
   }
 
   void emitClassFields(ClassElement classElement,
                        CodeBuffer buffer,
                        bool emitEndingComma,
                        { String superClass: "",
                          bool isNative: false}) {
     bool isFirstField = true;
     bool isAnythingOutput = false;
     if (!isNative) {
       buffer.add('"":"$superClass;');
       isAnythingOutput = true;
     }
     visitClassFields(classElement, (Element member,
                                     String name,
+                                    String accessorName,
                                     bool needsGetter,
                                     bool needsSetter,
                                     bool needsCheckedSetter) {
-      if (!getterAndSetterCanBeImplementedByFieldSpec(
-          member, name, needsGetter, needsSetter)) {
-        return;
-      }
       if (!isNative || needsCheckedSetter || needsGetter || needsSetter) {
         if (isFirstField) {
           isFirstField = false;
           if (!isAnythingOutput) {
             buffer.add('"":"');
             isAnythingOutput = true;
           }
         } else {
           buffer.add(",");
         }
-        buffer.add('$name');
+        buffer.add('$accessorName');
+        int flag = 0;
+        if (name != accessorName) {
+          buffer.add(':$name');
+          assert(needsGetter || needsSetter);
+          flag = RENAMING_FLAG;
+        }
         if (needsGetter && needsSetter) {
-          buffer.add(GETTER_SETTER_SUFFIX);
+          buffer.addCharCode(GETTER_SETTER_CODE + flag);
         } else if (needsGetter) {
-          buffer.add(GETTER_SUFFIX);
+          buffer.addCharCode(GETTER_CODE + flag);
         } else if (needsSetter) {
-          buffer.add(SETTER_SUFFIX);
+          buffer.addCharCode(SETTER_CODE + flag);
         }
       }
     });
     if (isAnythingOutput) {
       buffer.add('"');
       if (emitEndingComma) {
         buffer.add(',');
       }
     }
   }
 
   /** Each getter/setter must be prefixed with a ",\n ". */
   void emitClassGettersSetters(ClassElement classElement,
                                CodeBuffer buffer,
                                bool emitLeadingComma) {
     emitComma() {
       if (emitLeadingComma) {
         buffer.add(",\n ");
       } else {
         emitLeadingComma = true;
       }
     }
 
     visitClassFields(classElement, (Element member,
                                     String name,
+                                    String accessorName,
                                     bool needsGetter,
                                     bool needsSetter,
                                     bool needsCheckedSetter) {
-          if (name == null) throw 123;
-      if (getterAndSetterCanBeImplementedByFieldSpec(
-          member, name, needsGetter, needsSetter)) {
-        needsGetter = false;
-        needsSetter = false;
-      }
-      if (needsGetter) {
-        emitComma();
-        generateGetter(member, name, buffer);
-      }
-      if (needsSetter) {
-        emitComma();
-        generateSetter(member, name, buffer);
-      }
       if (needsCheckedSetter) {
         assert(!needsSetter);
         emitComma();
-        generateCheckedSetter(member, name, buffer);
+        generateCheckedSetter(member, name, accessorName, buffer);
       }
     });
   }
 
-  bool getterAndSetterCanBeImplementedByFieldSpec(Element member,
-      String name,
-      bool needsGetter,
-      bool needsSetter) {
-    if (needsGetter) {
-      if (namer.getterName(member.getLibrary(), member.name) != 'get\$$name') {
-        return false;
-      }
-    }
-    if (needsSetter) {
-      if (namer.setterName(member.getLibrary(), member.name) != 'set\$$name') {
-        return false;
-      }
-    }
-    return true;
-  }
-
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void generateClass(ClassElement classElement, CodeBuffer buffer) {
     assert(invariant(classElement, classElement.isDeclaration));
     if (classElement.isNative()) {
       nativeEmitter.generateNativeClass(classElement);
       return;
@@ skipping 211 matching lines @@
 
   void emitStaticFunctionGetters(CodeBuffer buffer) {
     Set<FunctionElement> functionsNeedingGetter =
         compiler.codegenWorld.staticFunctionsNeedingGetter;
     for (FunctionElement element in functionsNeedingGetter) {
       // The static function does not have the correct name. Since
       // [addParameterStubs] use the name to create its stubs we simply
       // create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
-          new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, element);
+          new ClosureInvocationElement(namer.closureInvocationSelector, element);
       String staticName = namer.getName(element);
       String invocationName = namer.instanceMethodName(callElement);
       String fieldAccess = '$isolateProperties.$staticName';
       buffer.add("$fieldAccess.$invocationName = $fieldAccess;\n");
       addParameterStubs(callElement, (String name, CodeBuffer value) {
         buffer.add('$fieldAccess.$name = $value;\n');
       });
       // If a static function is used as a closure we need to add its name
       // in case it is used in spawnFunction.
       String fieldName = namer.STATIC_CLOSURE_NAME_NAME;
@@ skipping 76 matching lines @@
 
       // Define the constructor with a name so that Object.toString can
       // find the class name of the closure class.
       emitBoundClosureClassHeader(
           mangledName, superName, extraArgWithoutComma, boundClosureBuffer);
       // Now add the methods on the closure class. The instance method does not
       // have the correct name. Since [addParameterStubs] use the name to create
       // its stubs we simply create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
-          new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, member);
-      
+          new ClosureInvocationElement(namer.closureInvocationSelector, member);
+
       String invocationName = namer.instanceMethodName(callElement);
       List<String> arguments = new List<String>(parameterCount);
       for (int i = 0; i < parameterCount; i++) {
         arguments[i] = "p$i";
       }
       String joinedArgs = Strings.join(arguments, ", ");
       boundClosureBuffer.add(
           "$invocationName: function($joinedArgs) {");
       String callArgs = hasExtraArgument
           ? joinedArgs.isEmpty
@@ skipping 55 matching lines @@
             : namer.instanceFieldName(memberLibrary, member.name);
         return new js.VariableUse('this').dot(fieldName);
       }
     }
 
     for (Selector selector in selectors) {
       if (selector.applies(member, compiler)) {
         String invocationName =
             namer.instanceMethodInvocationName(memberLibrary, member.name,
                                                selector);
-        SourceString callName = Namer.CLOSURE_INVOCATION_NAME;
+        SourceString callName = namer.closureInvocationSelector;
         String closureCallName =
             namer.instanceMethodInvocationName(memberLibrary, callName,
                                                selector);
 
         List<js.Parameter> parameters = <js.Parameter>[];
         List<js.Expression> arguments = <js.Expression>[];
         if (isInterceptorClass) {
           parameters.add(new js.Parameter(receiverArgumentName));
         }
 
@@ skipping 96 matching lines @@
               new js.PropertyAccess.field(
                   new js.VariableUse(isolateProperties),
                   name),
               constantInitializerExpression(constant));
       buffer.add(js.prettyPrint(init, compiler));
       buffer.add(';\n');
     }
   }
 
   void emitMakeConstantList(CodeBuffer buffer) {
-    buffer.add(namer.ISOLATE);
+    buffer.add(namer.isolateName);
     buffer.add(r'''.makeConstantList = function(list) {
   list.immutable$list = true;
   list.fixed$length = true;
   return list;
 };
 ''');
   }
 
   /**
    * Documentation wanted -- johnniwinther
@@ skipping 67 matching lines @@
       CodeBuffer argNames = new CodeBuffer();
       List<SourceString> names = selector.getOrderedNamedArguments();
       for (int i = 0; i < names.length; i++) {
         if (i != 0) argNames.add(', ');
         argNames.add('"');
         argNames.add(names[i].slowToString());
         argNames.add('"');
       }
       String internalName = namer.instanceMethodInvocationName(
           selector.library, new SourceString(methodName), selector);
+      Element createInvocationMirror =
+          compiler.findHelper(const SourceString('createInvocationMirror'));
       CodeBuffer buffer = new CodeBuffer();
       buffer.add('function($args) {\n');
       buffer.add('  return this.$noSuchMethodName('
-                     '\$.createInvocationMirror("$methodName", "$internalName",'
-                     ' $type, [$args], [$argNames]));\n');
+                        '${namer.isolateAccess(createInvocationMirror)}('
+                            '"$methodName", "$internalName",'
+                            '$type, [$args], [$argNames]));\n');
       buffer.add(' }');
       return buffer;
     }
 
     void addNoSuchMethodHandlers(SourceString ignore, Set<Selector> selectors) {
       // Cache the object class and type.
       ClassElement objectClass = compiler.objectClass;
       DartType objectType = objectClass.computeType(compiler);
 
       for (Selector selector in selectors) {
@@ skipping 125 matching lines @@
     buffer.add("""
 var \$globalThis = $currentIsolate;
 var \$globalState;
 var \$globals;
 var \$isWorker = false;
 var \$supportsWorkers = false;
 var \$thisScriptUrl;
 function \$static_init(){};
 
 function \$initGlobals(context) {
-  context.isolateStatics = new ${namer.ISOLATE}();
+  context.isolateStatics = new ${namer.isolateName}();
 }
 function \$setGlobals(context) {
   $currentIsolate = context.isolateStatics;
   \$globalThis = $currentIsolate;
 }
 $mainEnsureGetter
 """);
   return "${namer.isolateAccess(isolateMain)}($mainAccess)";
   }
 
   emitMain(CodeBuffer buffer) {
     if (compiler.isMockCompilation) return;
     Element main = compiler.mainApp.find(Compiler.MAIN);
     String mainCall = null;
     if (compiler.isolateLibrary != null) {
       Element isolateMain =
         compiler.isolateLibrary.find(Compiler.START_ROOT_ISOLATE);
       mainCall = buildIsolateSetup(buffer, main, isolateMain);
     } else {
       mainCall = '${namer.isolateAccess(main)}()';
     }
     buffer.add("""
 
 //
 // BEGIN invoke [main].
 //
-if (typeof document != 'undefined' && document.readyState != 'complete') {
+if (typeof document !== 'undefined' && document.readyState !== 'complete') {
   document.addEventListener('readystatechange', function () {
     if (document.readyState == 'complete') {
-      if (typeof dartMainRunner == 'function') {
+      if (typeof dartMainRunner === 'function') {
         dartMainRunner(function() { ${mainCall}; });
       } else {
         ${mainCall};
       }
     }
   }, false);
 } else {
-  if (typeof dartMainRunner == 'function') {
+  if (typeof dartMainRunner === 'function') {
     dartMainRunner(function() { ${mainCall}; });
   } else {
     ${mainCall};
   }
 }
 //
 // END invoke [main].
 //
 
 """);
@@ skipping 42 matching lines @@
               emitInterceptorCheck(cls, buffer);
             }
           }
           buffer.add('\n  return $objectName.prototype;\n};\n');
         });
   }
 
   String assembleProgram() {
     measure(() {
       mainBuffer.add(HOOKS_API_USAGE);
-      mainBuffer.add('function ${namer.ISOLATE}() {}\n');
+      mainBuffer.add('function ${namer.isolateName}() {}\n');
       mainBuffer.add('init();\n\n');
       // Shorten the code by using "$$" as temporary.
       classesCollector = r"$$";
       mainBuffer.add('var $classesCollector = {};\n');
       // Shorten the code by using [namer.CURRENT_ISOLATE] as temporary.
       isolateProperties = namer.CURRENT_ISOLATE;
       mainBuffer.add('var $isolateProperties = $isolatePropertiesName;\n');
       emitClasses(mainBuffer);
       mainBuffer.add(boundClosureBuffer);
       // Clear the buffer, so that we can reuse it for the native classes.
@@ skipping 15 matching lines @@
       // initialStatics.
       mainBuffer.add('var ${namer.CURRENT_ISOLATE} = null;\n');
       mainBuffer.add(boundClosureBuffer);
       emitFinishClassesInvocationIfNecessary(mainBuffer);
       // After this assignment we will produce invalid JavaScript code if we use
       // the classesCollector variable.
       classesCollector = 'classesCollector should not be used from now on';
 
       emitFinishIsolateConstructorInvocation(mainBuffer);
       mainBuffer.add(
-        'var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
+        'var ${namer.CURRENT_ISOLATE} = new ${namer.isolateName}();\n');
 
       nativeEmitter.assembleCode(mainBuffer);
       emitMain(mainBuffer);
       mainBuffer.add('function init() {\n');
       mainBuffer.add('$isolateProperties = {};\n');
       addDefineClassAndFinishClassFunctionsIfNecessary(mainBuffer);
       addLazyInitializerFunctionIfNecessary(mainBuffer);
       emitFinishIsolateConstructor(mainBuffer);
       mainBuffer.add('}\n');
       compiler.assembledCode = mainBuffer.toString();
@@ skipping 23 matching lines @@
 const String HOOKS_API_USAGE = """
 // Generated by dart2js, the Dart to JavaScript compiler.
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;