Move namer into javascript backend.

lib/compiler/implementation/js_backend/native_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.
 
 class NativeEmitter {
 
   CodeEmitterTask emitter;
   CodeBuffer nativeBuffer;
 
   // Classes that participate in dynamic dispatch. These are the
@@ skipping 30 matching lines @@
       : classesWithDynamicDispatch = new Set<ClassElement>(),
         nativeClasses = new Set<ClassElement>(),
         subtypes = new Map<ClassElement, List<ClassElement>>(),
         directSubtypes = new Map<ClassElement, List<ClassElement>>(),
         overriddenMethods = new Set<FunctionElement>(),
         nativeMethods = new Set<FunctionElement>(),
         redirectingMethods = new Map<FunctionElement, String>(),
         nativeBuffer = new CodeBuffer();
 
   Compiler get compiler => emitter.compiler;
+  JavaScriptBackend get backend => compiler.backend;
 
   void addRedirectingMethod(FunctionElement element, String name) {
     redirectingMethods[element] = name;
   }
 
   String get dynamicName {
     Element element = compiler.findHelper(
         const SourceString('dynamicFunction'));
-    return compiler.namer.isolateAccess(element);
+    return backend.namer.isolateAccess(element);
   }
 
   String get dynamicSetMetadataName {
     Element element = compiler.findHelper(
         const SourceString('dynamicSetMetadata'));
-    return compiler.namer.isolateAccess(element);
+    return backend.namer.isolateAccess(element);
   }
 
   String get typeNameOfName {
     Element element = compiler.findHelper(
         const SourceString('getTypeNameOf'));
-    return compiler.namer.isolateAccess(element);
+    return backend.namer.isolateAccess(element);
   }
 
   String get defPropName {
     Element element = compiler.findHelper(
         const SourceString('defineProperty'));
-    return compiler.namer.isolateAccess(element);
+    return backend.namer.isolateAccess(element);
   }
 
   String get toStringHelperName {
     Element element = compiler.findHelper(
         const SourceString('toStringForNativeObject'));
-    return compiler.namer.isolateAccess(element);
+    return backend.namer.isolateAccess(element);
   }
 
   String get defineNativeClassName
-      => '${compiler.namer.CURRENT_ISOLATE}.\$defineNativeClass';
+      => '${backend.namer.CURRENT_ISOLATE}.\$defineNativeClass';
 
   String get defineNativeClassFunction {
     return """
 function(cls, fields, methods) {
   var generateGetterSetter = ${emitter.generateGetterSetterFunction};
   for (var i = 0; i < fields.length; i++) {
     generateGetterSetter(fields[i], methods);
   }
   for (var method in methods) {
     $dynamicName(method)[cls] = methods[method];
   }
 }""";
   }
 
   void generateNativeLiteral(ClassElement classElement) {
     String quotedNative = classElement.nativeName.slowToString();
     String nativeCode = quotedNative.substring(2, quotedNative.length - 1);
-    String className = compiler.namer.getName(classElement);
+    String className = backend.namer.getName(classElement);
     nativeBuffer.add(className);
     nativeBuffer.add(' = ');
     nativeBuffer.add(nativeCode);
     nativeBuffer.add(';\n');
 
     void defineInstanceMember(String name, CodeBuffer value) {
       nativeBuffer.add("$className.$name = $value;\n");
     }
 
     for (Element member in classElement.localMembers) {
@@ skipping 55 matching lines @@
     List<ClassElement> result = directSubtypes[cls];
     return result === null ? const<ClassElement>[] : result;
   }
 
   void potentiallyConvertDartClosuresToJs(CodeBuffer code,
                                           FunctionElement member,
                                           List<String> argumentsBuffer) {
     FunctionSignature parameters = member.computeSignature(compiler);
     Element converter =
         compiler.findHelper(const SourceString('convertDartClosureToJS'));
-    String closureConverter = compiler.namer.isolateAccess(converter);
+    String closureConverter = backend.namer.isolateAccess(converter);
     parameters.forEachParameter((Element parameter) {
       String name = parameter.name.slowToString();
       // If [name] is not in [argumentsBuffer], then the parameter is
       // an optional parameter that was not provided for that stub.
       if (argumentsBuffer.indexOf(name) == -1) return;
       DartType type = parameter.computeType(compiler).unalias(compiler);
       if (type is FunctionType) {
         // The parameter type is a function type either directly or through
         // typedef(s).
         int arity = type.computeArity();
@@ skipping 24 matching lines @@
     String nativeName = classElement.nativeName.slowToString();
     String nativeArguments = Strings.join(nativeArgumentsBuffer, ",");
 
     CodeBuffer code = new CodeBuffer();
     potentiallyConvertDartClosuresToJs(code, member, argumentsBuffer);
 
     if (!nativeMethods.contains(member)) {
       // When calling a method that has a native body, we call it
       // with our calling conventions.
       String arguments = Strings.join(argumentsBuffer, ",");
-      code.add('  return this.${compiler.namer.getName(member)}($arguments)');
+      code.add('  return this.${backend.namer.getName(member)}($arguments)');
     } else {
       // When calling a JS method, we call it with the native name.
       String name = redirectingMethods[member];
       if (name === null) name = member.name.slowToString();
       code.add('  return this.$name($nativeArguments);');
     }
 
     if (isNativeLiteral(nativeName) || !overriddenMethods.contains(member)) {
       // Call the method directly.
       buffer.add(code.toString());
@@ skipping 141 matching lines @@
   bool requiresNativeIsCheck(Element element) {
     if (!element.isClass()) return false;
     ClassElement cls = element;
     if (cls.isNative()) return true;
     return isSupertypeOfNativeClass(element);
   }
 
   void emitIsChecks(Map<String, String> objectProperties) {
     for (Element type in compiler.codegenWorld.isChecks) {
       if (!requiresNativeIsCheck(type)) continue;
-      String name = compiler.namer.operatorIs(type);
+      String name = backend.namer.operatorIs(type);
       objectProperties[name] = 'function() { return false; }';
     }
   }
 
   void assembleCode(CodeBuffer targetBuffer) {
     if (nativeClasses.isEmpty()) return;
     emitDynamicDispatchMetadata();
     targetBuffer.add('$defineNativeClassName = '
                      '$defineNativeClassFunction;\n\n');
 
     // Because of native classes, we have to generate some is checks
     // by calling a method, instead of accessing a property. So we
     // attach to the JS Object prototype these methods that return
     // false, and will be overridden by subclasses when they have to
     // return true.
     Map<String, String> objectProperties = new Map<String, String>();
     emitIsChecks(objectProperties);
 
     // In order to have the toString method on every native class,
     // we must patch the JS Object prototype with a helper method.
-    String toStringName = compiler.namer.instanceMethodName(
+    String toStringName = backend.namer.instanceMethodName(
         null, const SourceString('toString'), 0);
     objectProperties[toStringName] =
         'function() { return $toStringHelperName(this); }';
 
     // If the native emitter has been asked to take care of the
     // noSuchMethod handlers, we do that now.
     if (handleNoSuchMethod) {
       emitter.emitNoSuchMethodHandlers((String name, CodeBuffer buffer) {
         objectProperties[name] = buffer.toString();
       });
@@ skipping 12 matching lines @@
         if (!first) targetBuffer.add(",\n");
         targetBuffer.add(" $name: $function");
         first = false;
       });
       targetBuffer.add("\n});\n\n");
     }
     targetBuffer.add('$nativeBuffer');
     targetBuffer.add('\n');
   }
 }