Start compiler refactoring to support more than a single backend.

lib/compiler/implementation/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 {
 
-  Compiler compiler;
+  CodeEmitterTask emitter;
   StringBuffer nativeBuffer;
 
   // Classes that participate in dynamic dispatch. These are the
   // classes that contain used members.
   Set<ClassElement> classesWithDynamicDispatch;
 
   // Native classes found in the application.
   Set<ClassElement> nativeClasses;
 
   // Caches the native subtypes of a native class.
   Map<ClassElement, List<ClassElement>> subtypes;
 
   // Caches the direct native subtypes of a native class.
   Map<ClassElement, List<ClassElement>> directSubtypes;
 
   // Caches the native methods that are overridden by a native class.
   // Note that the method that overrides does not have to be native:
   // it's the overridden method that must make sure it will dispatch
   // to its subclass if it sees an instance whose class is a subclass.
   Set<FunctionElement> overriddenMethods;
 
   // Caches the methods that should just call a native JS
   // implementation.
   Set<FunctionElement> nativeMethods;
 
-  NativeEmitter(this.compiler)
+  NativeEmitter(this.emitter)
       : 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>(),
         nativeBuffer = new StringBuffer();
 
+  Compiler get compiler() => emitter.compiler;
+
   String get dynamicName() {
     Element element = compiler.findHelper(
         const SourceString('dynamicFunction'));
     return compiler.namer.isolateAccess(element);
   }
 
   String get dynamicSetMetadataName() {
     Element element = compiler.findHelper(
         const SourceString('dynamicSetMetadata'));
     return compiler.namer.isolateAccess(element);
@@ skipping 16 matching lines @@
         const SourceString('toStringForNativeObject'));
     return compiler.namer.isolateAccess(element);
   }
 
   String get defineNativeClassName()
       => '${compiler.namer.CURRENT_ISOLATE}.\$defineNativeClass';
 
   String get defineNativeClassFunction() {
     return """
 function(cls, fields, methods) {
-  var generateGetterSetter = ${compiler.emitter.generateGetterSetterFunction};
+  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);
     nativeBuffer.add(className);
     nativeBuffer.add(' = ');
     nativeBuffer.add(nativeCode);
     nativeBuffer.add(';\n');
 
     void defineInstanceMember(String name, String value) {
       nativeBuffer.add("$className.$name = $value;\n");
     }
 
     for (Element member in classElement.members) {
       if (member.isInstanceMember()) {
-        compiler.emitter.addInstanceMember(member, defineInstanceMember);
+        emitter.addInstanceMember(member, defineInstanceMember);
       }
     }
   }
 
   bool isNativeLiteral(String quotedName) {
     return quotedName[1] === '=';
   }
 
   bool isNativeGlobal(String quotedName) {
     return quotedName[1] === '@';
@@ skipping 15 matching lines @@
     assert(classElement.backendMembers.isEmpty());
     String quotedName = classElement.nativeName.slowToString();
     if (isNativeLiteral(quotedName)) {
       generateNativeLiteral(classElement);
       // The native literal kind needs to be dealt with specially when
       // generating code for it.
       return;
     }
 
     StringBuffer fieldBuffer = new StringBuffer();
-    compiler.emitter.emitClassFields(classElement, fieldBuffer);
+    emitter.emitClassFields(classElement, fieldBuffer);
 
     StringBuffer methodBuffer = new StringBuffer();
-    compiler.emitter.emitInstanceMembers(classElement, methodBuffer);
+    emitter.emitInstanceMembers(classElement, methodBuffer);
 
     if (methodBuffer.isEmpty() && fieldBuffer.isEmpty()) return;
 
     String nativeName = toNativeName(classElement);
     nativeBuffer.add("$defineNativeClassName('$nativeName', [");
     nativeBuffer.add(fieldBuffer);
     nativeBuffer.add('], {');
     nativeBuffer.add(methodBuffer);
     nativeBuffer.add('\n});\n\n');
 
@@ skipping 230 matching lines @@
     String toStringName = compiler.namer.instanceMethodName(
         null, const SourceString('toString'), 0);
     objectProperties.add("$defPropName(Object.prototype, '$toStringName', ");
     objectProperties.add(
         'function() { return $toStringHelperName(this); });\n');
 
     targetBuffer.add('$defineNativeClassName = $defineNativeClassFunction;\n');
     targetBuffer.add('$objectProperties$nativeBuffer\n');
   }
 }