Remove static fields in the namer.

lib/compiler/implementation/emitter.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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 621 matching lines @@
 
   void emitStaticFunctionGetters(StringBuffer buffer) {
     Set<FunctionElement> functionsNeedingGetter =
         compiler.codegenWorld.staticFunctionsNeedingGetter;
     for (FunctionElement element in functionsNeedingGetter) {
       // The static function does not have the correct name. Since
       // [addParameterStubs] use the name to create its stubs we simply
       // create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
-          new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, element);
+          new ClosureInvocationElement(namer.CLOSURE_INVOCATION_NAME, element);
       String staticName = namer.getName(element);
       int parameterCount = element.parameterCount(compiler);
       String invocationName =
           namer.instanceMethodName(element.getLibrary(), callElement.name,
                                    parameterCount);
       String fieldAccess = '$isolateProperties.$staticName';
       buffer.add("$fieldAccess.$invocationName = $fieldAccess;\n");
       addParameterStubs(callElement, (String name, String value) {
         buffer.add('$fieldAccess.$name = $value;\n');
       });
       // If a static function is used as a closure we need to add its name
       // in case it is used in spawnFunction.
-      String fieldName = Namer.STATIC_CLOSURE_NAME_NAME;
+      String fieldName = namer.STATIC_CLOSURE_NAME_NAME;
       buffer.add('$fieldAccess.$fieldName = "$staticName";\n');
     }
   }
 
   void emitDynamicFunctionGetter(FunctionElement member,
                                  defineInstanceMember(String invocationName,
                                                       String definition)) {
     // For every method that has the same name as a property-get we create a
     // getter that returns a bound closure. Say we have a class 'A' with method
     // 'foo' and somewhere in the code there is a dynamic property get of
@@ skipping 33 matching lines @@
       // Define the constructor with a name so that Object.toString can
       // find the class name of the closure class.
       boundClosureBuffer.add("$defineClassName('$mangledName', '$superName', ");
       boundClosureBuffer.add("['self', 'target'], {\n");
 
       // Now add the methods on the closure class. The instance method does not
       // have the correct name. Since [addParameterStubs] use the name to create
       // its stubs we simply create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
-          new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, member);
+          new ClosureInvocationElement(namer.CLOSURE_INVOCATION_NAME, member);
 
       String invocationName =
           namer.instanceMethodName(member.getLibrary(),
                                    callElement.name, parameterCount);
       List<String> arguments = new List<String>(parameterCount);
       for (int i = 0; i < parameterCount; i++) {
         arguments[i] = "p$i";
       }
       String joinedArgs = Strings.join(arguments, ", ");
       boundClosureBuffer.add(
@@ skipping 32 matching lines @@
     } else {
       String name = namer.instanceFieldName(member.getEnclosingClass(),
                                             member.name);
       getter = "this.$name";
     }
     for (Selector selector in selectors) {
       if (selector.applies(member, compiler)) {
         String invocationName =
             namer.instanceMethodInvocationName(member.getLibrary(), member.name,
                                                selector);
-        SourceString callName = Namer.CLOSURE_INVOCATION_NAME;
+        SourceString callName = namer.CLOSURE_INVOCATION_NAME;
         String closureCallName =
             namer.instanceMethodInvocationName(member.getLibrary(), callName,
                                                selector);
         List<String> arguments = <String>[];
         for (int i = 0; i < selector.argumentCount; i++) {
           arguments.add("arg$i");
         }
         String joined = Strings.join(arguments, ", ");
         defineInstanceMember(
             invocationName,
@@ skipping 90 matching lines @@
       buffer.add("      ? this.$noSuchMethodName('$methodName', [$args])\n");
       buffer.add("      : $runtimeObjectPrototype.$noSuchMethodName.call(");
       buffer.add("this, '$methodName', [$args])\n");
       buffer.add('}');
       return buffer.toString();
     }
 
     compiler.codegenWorld.invokedNames.forEach((SourceString methodName,
                                             Set<Selector> selectors) {
       if (objectClass.lookupLocalMember(methodName) === null
-          && methodName != Namer.OPERATOR_EQUALS) {
+          && methodName != Elements.OPERATOR_EQUALS) {
         for (Selector selector in selectors) {
           if (methodName.isPrivate()) {
             for (LibraryElement lib in libraries) {
               String jsName =
                 namer.instanceMethodInvocationName(lib, methodName, selector);
               String method =
                   generateMethod(methodName.slowToString(), selector);
               defineInstanceMember(jsName, method);
             }
           } else {
@@ skipping 145 matching lines @@
       mainBuffer.add('function init() {\n');
       mainBuffer.add('  $isolateProperties = {};\n');
       addDefineClassAndFinishClassFunctionsIfNecessary(mainBuffer);
       emitFinishIsolateConstructor(mainBuffer);
       mainBuffer.add('}\n');
       compiler.assembledCode = mainBuffer.toString();
     });
     return compiler.assembledCode;
   }
 }