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

pkg/compiler/lib/src/ssa/codegen.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 ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 1455 matching lines @@
     // Depending on how the then/else branches terminate
     // (e.g., return/throw/break) there can be any number of these.
     List<HBasicBlock> dominated = node.block.dominatedBlocks;
     for (int i = 2; i < dominated.length; i++) {
       visitBasicBlock(dominated[i]);
     }
   }
 
   void visitInterceptor(HInterceptor node) {
     registry.registerSpecializedGetInterceptor(node.interceptedClasses);
-    String name = backend.namer.getInterceptorName(
-        backend.getInterceptorMethod, node.interceptedClasses);
+    String name = backend.namer.nameForGetInterceptor(node.interceptedClasses);
     var isolate = new js.VariableUse(
         backend.namer.globalObjectFor(backend.interceptorsLibrary));
     use(node.receiver);
     List<js.Expression> arguments = <js.Expression>[pop()];
     push(js.propertyCall(isolate, name, arguments), node);
     registry.registerUseInterceptor();
   }
 
   visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     use(node.receiver);
@@ skipping 25 matching lines @@
     if (methodName == null) {
       methodName = backend.namer.invocationName(node.selector);
       registerMethodInvoke(node);
     }
     push(js.propertyCall(object, methodName, arguments), node);
   }
 
   void visitInvokeConstructorBody(HInvokeConstructorBody node) {
     use(node.inputs[0]);
     js.Expression object = pop();
-    String methodName = backend.namer.getNameOfInstanceMember(node.element);
+    String methodName = backend.namer.instanceMethodName(node.element);
     List<js.Expression> arguments = visitArguments(node.inputs);
     push(js.propertyCall(object, methodName, arguments), node);
     registry.registerStaticUse(node.element);
   }
 
   void visitOneShotInterceptor(HOneShotInterceptor node) {
     List<js.Expression> arguments = visitArguments(node.inputs);
     var isolate = new js.VariableUse(
         backend.namer.globalObjectFor(backend.interceptorsLibrary));
     Selector selector = getOptimizedSelectorFor(node, node.selector);
@@ skipping 119 matching lines @@
           TypeMask receiverType =
               new TypeMask.nonNullExact(superClass, compiler.world);
           selector = new TypedSelector(receiverType, selector, compiler.world);
           // TODO(floitsch): we know the target. We shouldn't register a
           // dynamic getter.
           registry.registerDynamicGetter(selector);
           registry.registerGetterForSuperMethod(node.element);
           methodName = backend.namer.invocationName(selector);
         } else {
           assert(invariant(node, compiler.hasIncrementalSupport));
-          methodName = backend.namer.getNameOfInstanceMember(superMethod);
+          methodName = backend.namer.instanceMethodName(superMethod);
         }
         push(js.js('#.#.call(#)',
                    [backend.emitter.prototypeAccess(superClass,
                                                     hasBeenInstantiated: true),
                     methodName, visitArguments(node.inputs, start: 0)]),
              node);
       } else {
         use(node.receiver);
         push(
           js.js('#.#(#)', [
-            pop(), backend.namer.getNameOfAliasedSuperMember(superMethod),
+            pop(), backend.namer.aliasedSuperMemberPropertyName(superMethod),
             visitArguments(node.inputs, start: 1)]), // Skip receiver argument.
           node);
       }
     }
   }
 
   visitFieldGet(HFieldGet node) {
     use(node.receiver);
     Element element = node.element;
     if (node.isNullCheck) {
@@ skipping 940 matching lines @@
       if (backend.isInterceptorClass(element.enclosingClass)) {
         int index = RuntimeTypes.getTypeVariableIndex(element);
         js.Expression receiver = pop();
         js.Expression helper = backend.emitter
             .staticFunctionAccess(helperElement);
         push(js.js(r'#(#.$builtinTypeInfo && #.$builtinTypeInfo[#])',
                 [helper, receiver, receiver, js.js.number(index)]));
       } else {
         backend.emitter.registerReadTypeVariable(element);
         push(js.js('#.#()',
-                [pop(), backend.namer.readTypeVariableName(element)]));
+                [pop(), backend.namer.nameForReadTypeVariable(element)]));
       }
     } else {
       push(js.js('#(#)', [
           backend.emitter.staticFunctionAccess(
               backend.findHelper('convertRtiToRuntimeType')),
           pop()]));
     }
   }
 
   void visitInterfaceType(HInterfaceType node) {
@@ skipping 22 matching lines @@
   js.PropertyAccess accessHelper(String name) {
     Element helper = backend.findHelper(name);
     if (helper == null) {
       // For mocked-up tests.
       return js.js('(void 0).$name');
     }
     registry.registerStaticUse(helper);
     return backend.emitter.staticFunctionAccess(helper);
   }
 }