Avoid use of empty string as a property name.

sdk/lib/_internal/compiler/implementation/js_emitter/code_emitter_task.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 dart2js.js_emitter;
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
@@ skipping 313 matching lines @@
            js('var constructorsList = []')]),
       js.forIn('cls', 'collectedClasses', [
         js.if_('hasOwnProperty.call(collectedClasses, cls)', [
           js('var desc = collectedClasses[cls]'),
           js.if_('desc instanceof Array', js('desc = desc[1]')),
 
           /* The 'fields' are either a constructor function or a
            * string encoding fields, constructor and superclass.  Get
            * the superclass and the fields in the format
            *   '[name/]Super;field1,field2'
-           * from the null-string property on the descriptor.
+           * from the CLASS_DESCRIPTOR_PROPERTY property on the descriptor.
            * The 'name/' is optional and contains the name that should be used
            * when printing the runtime type string.  It is used, for example, to
            * print the runtime type JSInt as 'int'.
            */
-          js('var classData = desc[""], supr, name = cls, fields = classData'),
+           js('var classData = desc["${namer.classDescriptorProperty}"], '
+              'supr, name = cls, fields = classData'),
           optional(
               backend.hasRetainedMetadata,
               js.if_('typeof classData == "object" && '
                      'classData instanceof Array',
                      [js('classData = fields = classData[0]')])),
 
           js.if_('typeof classData == "string"', [
             js('var split = classData.split("/")'),
             js.if_('split.length == 2', [
               js('name = split[0]'),
@@ skipping 471 matching lines @@
   }
 
   void emitStaticFunctions() {
     bool isStaticFunction(Element element) =>
         !element.isInstanceMember() && !element.isField();
 
     Iterable<Element> elements =
         backend.generatedCode.keys.where(isStaticFunction);
 
     for (Element element in Elements.sortedByPosition(elements)) {
-      ClassBuilder builder = new ClassBuilder();
+      ClassBuilder builder = new ClassBuilder(namer);
       containerBuilder.addMember(element, builder);
       getElementDecriptor(element).properties.addAll(builder.properties);
     }
   }
 
   void emitStaticNonFinalFieldInitializations(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     Iterable<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in Elements.sortedByPosition(staticNonFinalFields)) {
@@ skipping 501 matching lines @@
         classesCollector = r"$$";
         if (compiler.enableMinification) {
           mainBuffer.write(';');
         }
 
         for (Element element in elementDescriptors.keys) {
           // TODO(ahe): Should iterate over all libraries.  Otherwise, we will
           // not see libraries that only have fields.
           if (element.isLibrary()) {
             LibraryElement library = element;
-            ClassBuilder builder = new ClassBuilder();
+            ClassBuilder builder = new ClassBuilder(namer);
             if (classEmitter.emitFields(
                     library, builder, null, emitStatics: true)) {
               OutputUnit mainUnit = compiler.deferredLoadTask.mainOutputUnit;
               getElementDescriptorForOutputUnit(library, mainUnit)
                   .properties.addAll(builder.toObjectInitializer().properties);
             }
           }
         }
 
         if (!mangledFieldNames.isEmpty) {
@@ skipping 177 matching lines @@
     });
     return compiler.assembledCode;
   }
 
   ClassBuilder getElementDescriptorForOutputUnit(Element element,
                                                  OutputUnit outputUnit) {
     Map<OutputUnit, ClassBuilder> descriptors =
         elementDescriptors.putIfAbsent(
             element, () => new Map<OutputUnit, ClassBuilder>());
     return descriptors.putIfAbsent(outputUnit,
-        () => new ClassBuilder());
+        () => new ClassBuilder(namer));
   }
 
   ClassBuilder getElementDecriptor(Element element) {
     Element owner = element.getLibrary();
     if (!element.isTopLevel() && !element.isNative()) {
       // For static (not top level) elements, record their code in a buffer
       // specific to the class. For now, not supported for native classes and
       // native elements.
       ClassElement cls =
           element.getEnclosingClassOrCompilationUnit().declaration;
@@ skipping 82 matching lines @@
     String sourceMap = buildSourceMap(mainBuffer, compiledFile);
     compiler.outputProvider(name, 'js.map')
         ..add(sourceMap)
         ..close();
   }
 
   void registerReadTypeVariable(TypeVariableElement element) {
     readTypeVariables.add(element);
   }
 }