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);
     emitStubs(cls.callStubs, builder);
     emitStubs(cls.typeVariableReaderStubs, 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.
+      jsAst.Fun function = js('function() { return this; }');
+      String name = namer.getterForPublicMember(Compiler.CALL_OPERATOR_NAME);
+      builder.addProperty(name, function);
+    }
+
     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 321 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]));
     }
   }
 
   void generateReflectionDataForFieldGetterOrSetter(Element member,
                                                     String name,
                                                     ClassBuilder builder,
                                                     {bool isGetter}) {
     Selector selector = isGetter
         ? new Selector.getter(member.name, member.library)
         : new Selector.setter(member.name, member.library);
     String reflectionName = emitter.getReflectionName(selector, name);
     if (reflectionName != null) {
       var reflectable =
           js(backend.isAccessibleByReflection(member) ? '1' : '0');
       builder.addProperty('+$reflectionName', reflectable);
     }
   }
 }