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

pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart

 // Copyright (c) 2014, 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 OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 132 matching lines @@
   String get finishIsolateConstructorName
       => '${namer.isolateName}.\$finishIsolateConstructor';
   String get isolatePropertiesName
       => '${namer.isolateName}.${namer.isolatePropertiesName}';
   String get lazyInitializerProperty
       => r'$lazy';
   String get lazyInitializerName
       => '${namer.isolateName}.${lazyInitializerProperty}';
   String get initName => 'init';
 
-  String get makeConstListProperty
-      => namer.getMappedInstanceName('makeConstantList');
+  String get makeConstListProperty => namer.internalGlobal('makeConstantList');
 
   /// The name of the property that contains all field names.
   ///
   /// This property is added to constructors when isolate support is enabled.
   static const String FIELD_NAMES_PROPERTY_NAME = r"$__fields__";
 
   /// For deferred loading we communicate the initializers via this global var.
   final String deferredInitializers = r"$dart_deferred_initializers";
 
-  /// All the global state can be passed around with this variable.
-  String get globalsHolder => namer.getMappedGlobalName("globalsHolder");
+  /// Contains the global state that is needed to initialize and load a
+  /// deferred library.
+  String get globalsHolder => namer.internalGlobal("globalsHolder");
 
   @override
   jsAst.Expression generateEmbeddedGlobalAccess(String global) {
     return js(generateEmbeddedGlobalAccessString(global));
   }
 
   String generateEmbeddedGlobalAccessString(String global) {
     // TODO(floitsch): don't use 'init' as global embedder storage.
     return '$initName.$global';
   }
 
   jsAst.PropertyAccess globalPropertyAccess(Element element) {
-    String name = namer.getNameX(element);
+    String name = namer.globalPropertyName(element);
     jsAst.PropertyAccess pa = new jsAst.PropertyAccess.field(
         new jsAst.VariableUse(namer.globalObjectFor(element)),
         name);
     return pa;
   }
 
   @override
   jsAst.Expression isolateLazyInitializerAccess(FieldElement element) {
      return jsAst.js('#.#', [namer.globalObjectFor(element),
-                             namer.getLazyInitializerName(element)]);
+                             namer.lazyInitializerName(element)]);
    }
 
   @override
   jsAst.Expression isolateStaticClosureAccess(FunctionElement element) {
      return jsAst.js('#.#()',
-         [namer.globalObjectFor(element), namer.getStaticClosureName(element)]);
+         [namer.globalObjectFor(element), namer.staticClosureName(element)]);
    }
 
   @override
   jsAst.PropertyAccess staticFieldAccess(FieldElement element) {
     return globalPropertyAccess(element);
   }
 
   @override
   jsAst.PropertyAccess staticFunctionAccess(FunctionElement element) {
     return globalPropertyAccess(element);
@@ skipping 508 matching lines @@
       containerBuilder.addMember(element, builder);
       getElementDescriptor(element).properties.addAll(builder.properties);
     }
   }
 
   void emitStaticNonFinalFieldInitializations(CodeOutput output,
                                               OutputUnit outputUnit) {
     void emitInitialization(Element element, jsAst.Expression initialValue) {
       jsAst.Expression init =
         js('$isolateProperties.# = #',
-            [namer.getNameOfGlobalField(element), initialValue]);
+            [namer.globalPropertyName(element), initialValue]);
       output.addBuffer(jsAst.prettyPrint(init, compiler,
                                          monitor: compiler.dumpInfoTask));
       output.add('$N');
     }
 
     bool inMainUnit = (outputUnit == compiler.deferredLoadTask.mainOutputUnit);
     JavaScriptConstantCompiler handler = backend.constants;
 
     Iterable<Element> fields = task.outputStaticNonFinalFieldLists[outputUnit];
     // If the outputUnit does not contain any static non-final fields, then
@@ skipping 50 matching lines @@
     if (code == null) return null;
     // The code only computes the initial value. We build the lazy-check
     // here:
     //   lazyInitializer(prototype, 'name', fieldName, getterName, initial);
     // The name is used for error reporting. The 'initial' must be a
     // closure that constructs the initial value.
     return js('#(#,#,#,#,#)',
         [js(lazyInitializerName),
             js(isolateProperties),
             js.string(element.name),
-            js.string(namer.getNameX(element)),
-            js.string(namer.getLazyInitializerName(element)),
+            js.string(namer.globalPropertyName(element)),
+            js.string(namer.lazyInitializerName(element)),
             code]);
   }
 
   bool isConstantInlinedOrAlreadyEmitted(ConstantValue constant) {
     if (constant.isFunction) return true;    // Already emitted.
     if (constant.isPrimitive) return true;   // Inlined.
     if (constant.isDummy) return true;       // Inlined.
     // The name is null when the constant is already a JS constant.
     // TODO(floitsch): every constant should be registered, so that we can
     // share the ones that take up too much space (like some strings).
@@ skipping 436 matching lines @@
       ClassBuilder builder = new ClassBuilder(typedef, namer);
       builder.addProperty(embeddedNames.TYPEDEF_TYPE_PROPERTY_NAME,
                           js.number(typeIndex));
       builder.addProperty(embeddedNames.TYPEDEF_PREDICATE_PROPERTY_NAME,
                           js.boolean(true));
 
       // We can be pretty sure that the objectClass is initialized, since
       // typedefs are only emitted with reflection, which requires lots of
       // classes.
       assert(compiler.objectClass != null);
-      builder.superName = namer.getNameOfClass(compiler.objectClass);
+      builder.superName = namer.className(compiler.objectClass);
       jsAst.Node declaration = builder.toObjectInitializer();
-      String mangledName = namer.getNameX(typedef);
+      String mangledName = namer.globalPropertyName(typedef);
       String reflectionName = getReflectionName(typedef, mangledName);
       getElementDescriptor(library)
           ..addProperty(mangledName, declaration)
           ..addProperty("+$reflectionName", js.string(''));
       // Also emit a trivial constructor for CSP mode.
       String constructorName = mangledName;
       jsAst.Expression constructorAst = js('function() {}');
       List<String> fieldNames = [];
       emitPrecompiledConstructor(mainOutputUnit,
                                  constructorName,
@@ skipping 773 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }