dart2js: Refactoring, documentation, and a few bugfixes in Namer class.

pkg/compiler/lib/src/js_emitter/old_emitter/class_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 ClassEmitter extends CodeEmitterHelper {
 
   ClassStubGenerator get _stubGenerator =>
       new ClassStubGenerator(compiler, namer, backend);
 
   /**
    * Documentation wanted -- johnniwinther
    */
   void emitClass(Class cls, ClassBuilder enclosingBuilder) {
     ClassElement classElement = cls.element;
 
     assert(invariant(classElement, classElement.isDeclaration));
 
     emitter.needsClassSupport = true;
 
     ClassElement superclass = classElement.superclass;
     String superName = "";
     if (superclass != null) {
-      superName = namer.getNameOfClass(superclass);
+      superName = namer.className(superclass);
     }
 
     if (cls.isMixinApplication) {
       MixinApplication mixinApplication = cls;
       String mixinName = mixinApplication.mixinClass.name;
       superName = '$superName+$mixinName';
       emitter.needsMixinSupport = true;
     }
 
     ClassBuilder builder = new ClassBuilder(classElement, namer);
     builder.superName = superName;
     emitConstructorsForCSP(cls);
     emitFields(cls, builder);
     emitCheckedClassSetters(cls, builder);
     emitClassGettersSettersForCSP(cls, builder);
     emitInstanceMembers(cls, builder);
     emitCallStubs(cls, builder);
     emitRuntimeTypeInformation(cls, builder);
     emitNativeInfo(cls, builder);
 
     if (classElement == backend.closureClass) {
       // We add a special getter here to allow for tearing off a closure from
       // itself.
-      String name = namer.getMappedInstanceName(Compiler.CALL_OPERATOR_NAME);
       jsAst.Fun function = js('function() { return this; }');
-      builder.addProperty(namer.getterNameFromAccessorName(name), function);
+      String name = namer.getterForPublicMember(Compiler.CALL_OPERATOR_NAME);
+      builder.addProperty(name, function);
     }
 
     emitTypeVariableReaders(classElement, builder);
 
     emitClassBuilderWithReflectionData(cls, builder, enclosingBuilder);
   }
   /**
   * Emits the precompiled constructor when in CSP mode.
   */
   void emitConstructorsForCSP(Class cls) {
     List<String> fieldNames = <String>[];
 
     if (!compiler.useContentSecurityPolicy) return;
 
     if (!cls.onlyForRti && !cls.isNative) {
       fieldNames = cls.fields.map((Field field) => field.name).toList();
     }
 
     ClassElement classElement = cls.element;
 
     jsAst.Expression constructorAst =
         _stubGenerator.generateClassConstructor(classElement, fieldNames);
 
-    String constructorName = namer.getNameOfClass(classElement);
+    String constructorName = namer.className(classElement);
     OutputUnit outputUnit =
         compiler.deferredLoadTask.outputUnitForElement(classElement);
     emitter.emitPrecompiledConstructor(
         outputUnit, constructorName, constructorAst, fieldNames);
   }
 
   /// Returns `true` if fields added.
   bool emitFields(FieldContainer container,
                   ClassBuilder builder,
                   { bool classIsNative: false,
@@ skipping 50 matching lines @@
           assert(!classIsNative);
         } else {
           // Emit (possibly renaming) field name so we can add accessors at
           // runtime.
           if (name != accessorName) {
             fieldName = '$accessorName:$name';
           }
 
           if (field.needsInterceptedGetter) {
             emitter.interceptorEmitter.interceptorInvocationNames.add(
-                namer.getterName(fieldElement));
+                namer.getterForElement(fieldElement));
           }
           // TODO(16168): The setter creator only looks at the getter-name.
           // Even though the setter could avoid the interceptor convention we
           // currently still need to add the additional argument.
           if (field.needsInterceptedGetter || field.needsInterceptedSetter) {
             emitter.interceptorEmitter.interceptorInvocationNames.add(
-                namer.setterName(fieldElement));
+                namer.setterForElement(fieldElement));
           }
 
           int code = field.getterFlags + (field.setterFlags << 2);
           if (code == 0) {
             compiler.internalError(fieldElement,
                 'Field code is 0 ($fieldElement).');
           } else {
             fieldCode = FIELD_CODE_CHARACTERS[code - FIRST_FIELD_CODE];
           }
         }
@@ skipping 323 matching lines @@
     DartType type = member.type;
     return type.treatAsDynamic || (type.element == compiler.objectClass);
   }
 
   void generateCheckedSetter(Element member,
                              String fieldName,
                              String accessorName,
                              ClassBuilder builder) {
     jsAst.Expression code = backend.generatedCode[member];
     assert(code != null);
-    String setterName = namer.setterNameFromAccessorName(accessorName);
+    String setterName = namer.deriveSetterName(accessorName);
     compiler.dumpInfoTask.registerElementAst(member,
         builder.addProperty(setterName, code));
     generateReflectionDataForFieldGetterOrSetter(
         member, setterName, builder, isGetter: false);
   }
 
   void emitGetterForCSP(Element member, String fieldName, String accessorName,
                         ClassBuilder builder) {
     jsAst.Expression function =
         _stubGenerator.generateGetter(member, fieldName);
 
-    String getterName = namer.getterNameFromAccessorName(accessorName);
+    String getterName = namer.deriveGetterName(accessorName);
     ClassElement cls = member.enclosingClass;
-    String className = namer.getNameOfClass(cls);
+    String className = namer.className(cls);
     OutputUnit outputUnit =
         compiler.deferredLoadTask.outputUnitForElement(member);
     emitter.cspPrecompiledFunctionFor(outputUnit).add(
         js('#.prototype.# = #', [className, getterName, function]));
     if (backend.isAccessibleByReflection(member)) {
       emitter.cspPrecompiledFunctionFor(outputUnit).add(
           js('#.prototype.#.${namer.reflectableField} = 1',
               [className, getterName]));
     }
   }
 
   void emitSetterForCSP(Element member, String fieldName, String accessorName,
                         ClassBuilder builder) {
     jsAst.Expression function =
         _stubGenerator.generateSetter(member, fieldName);
 
-    String setterName = namer.setterNameFromAccessorName(accessorName);
+    String setterName = namer.deriveSetterName(accessorName);
     ClassElement cls = member.enclosingClass;
-    String className = namer.getNameOfClass(cls);
+    String className = namer.className(cls);
     OutputUnit outputUnit =
         compiler.deferredLoadTask.outputUnitForElement(member);
     emitter.cspPrecompiledFunctionFor(outputUnit).add(
         js('#.prototype.# = #', [className, setterName, function]));
     if (backend.isAccessibleByReflection(member)) {
       emitter.cspPrecompiledFunctionFor(outputUnit).add(
           js('#.prototype.#.${namer.reflectableField} = 1',
               [className, setterName]));
     }
   }
@@ skipping 22 matching lines @@
           emitTypeVariableReader(cls, builder, parameter.element);
         }
       }
       superclass = superclass.superclass;
     }
   }
 
   void emitTypeVariableReader(ClassElement cls,
                               ClassBuilder builder,
                               TypeVariableElement element) {
-    String name = namer.readTypeVariableName(element);
+    String name = namer.nameForReadTypeVariable(element);
     int index = RuntimeTypes.getTypeVariableIndex(element);
     jsAst.Expression computeTypeVariable;
 
     Substitution substitution =
         backend.rti.computeSubstitution(
             cls, element.typeDeclaration, alwaysGenerateFunction: true);
     if (substitution != null) {
       computeTypeVariable =
           js(r'#.apply(null, this.$builtinTypeInfo)',
              substitution.getCodeForVariable(index, backend.rti));
     } else {
       // TODO(ahe): These can be generated dynamically.
       computeTypeVariable =
           js(r'this.$builtinTypeInfo && this.$builtinTypeInfo[#]',
               js.number(index));
     }
     jsAst.Expression convertRtiToRuntimeType = emitter
         .staticFunctionAccess(backend.findHelper('convertRtiToRuntimeType'));
     compiler.dumpInfoTask.registerElementAst(element,
         builder.addProperty(name,
             js('function () { return #(#) }',
                 [convertRtiToRuntimeType, computeTypeVariable])));
   }
 }