Write our JS blobs for handling native classes in Dart.

frog/leg/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 19 matching lines @@
     tmp.prototype = parent.prototype;
     child.prototype = new tmp();
     child.prototype.constructor = child;
   }
 }''';
 
   bool addedInheritFunction = false;
   final Namer namer;
   final NativeEmitter nativeEmitter;
   Set<ClassElement> generatedClasses;
+  StringBuffer mainBuffer;
 
   CodeEmitterTask(Compiler compiler)
       : namer = compiler.namer,
         nativeEmitter = new NativeEmitter(compiler),
         generatedClasses = new Set<ClassElement>(),
+        mainBuffer = new StringBuffer(),
         super(compiler);
 
   String get name() => 'CodeEmitter';
 
   String get inheritsName() => '${namer.ISOLATE}.\$inherits';
 
   String get objectClassName() {
     ClassElement objectClass =
         compiler.coreLibrary.find(const SourceString('Object'));
     return namer.isolatePropertyAccess(objectClass);
   }
 
-  void addInheritFunctionIfNecessary(StringBuffer buffer) {
+  void addInheritFunctionIfNecessary() {
     if (addedInheritFunction) return;
     addedInheritFunction = true;
-    buffer.add('$inheritsName = ');
-    buffer.add(INHERIT_FUNCTION);
-    buffer.add(';\n');
+    mainBuffer.add('$inheritsName = ');
+    mainBuffer.add(INHERIT_FUNCTION);
+    mainBuffer.add(';\n');
   }
 
   void addParameterStub(FunctionElement member,
                         String attachTo(String invocationName),
                         StringBuffer buffer,
                         Selector selector,
                         bool isNative) {
     FunctionParameters parameters = member.computeParameters(compiler);
     int positionalArgumentCount = selector.positionalArgumentCount;
     if (positionalArgumentCount == parameters.parameterCount) {
@@ skipping 78 matching lines @@
         }
       }
       count++;
     });
     String parametersString = Strings.join(parametersBuffer, ",");
     buffer.add('$parametersString) {\n');
 
     if (isNative) {
       nativeEmitter.emitParameterStub(
           member, invocationName, parametersString, argumentsBuffer,
-          indexOfLastOptionalArgumentInParameters, buffer);
+          indexOfLastOptionalArgumentInParameters);
     } else {
       String arguments = Strings.join(argumentsBuffer, ",");
       buffer.add('  return this.${namer.getName(member)}($arguments)');
   }
     buffer.add('\n}\n');
   }
 
   void addParameterStubs(FunctionElement member,
                          String attachTo(String invocationName),
                          StringBuffer buffer,
@@ skipping 83 matching lines @@
         generateFieldInit(element);
       }
 
       classElement = classElement.superclass;
     } while(classElement !== null);
   }
 
   void emitInherits(ClassElement cls, StringBuffer buffer) {
     ClassElement superclass = cls.superclass;
     if (superclass !== null) {
-      addInheritFunctionIfNecessary(buffer);
+      addInheritFunctionIfNecessary();
       String className = namer.isolatePropertyAccess(cls);
       String superName = namer.isolatePropertyAccess(superclass);
       buffer.add('${inheritsName}($className, $superName);\n');
     }
   }
 
   void ensureGenerated(ClassElement classElement, StringBuffer buffer) {
     if (classElement == null) return;
     if (generatedClasses.contains(classElement)) return;
     generatedClasses.add(classElement);
     generateClass(classElement, buffer);
   }
 
   void generateClass(ClassElement classElement, StringBuffer buffer) {
     ensureGenerated(classElement.superclass, buffer);
 
     if (classElement.isNative()) {
-      nativeEmitter.generateNativeClass(classElement, buffer);
+      nativeEmitter.generateNativeClass(classElement);
       return;
+    } else {
+      // TODO(ngeoffray): Instead of switching between buffer, we
+      // should create code sections, and decide where to emit them at
+      // the end.
+      buffer = mainBuffer;
     }
 
     String className = namer.isolatePropertyAccess(classElement);
     String constructorName = namer.safeName(classElement.name.slowToString());
     buffer.add('$className = function $constructorName(');
     StringBuffer bodyBuffer = new StringBuffer();
     // If the class is never instantiated we still need to set it up for
     // inheritance purposes, but we can leave its JavaScript constructor empty.
     if (compiler.universe.instantiatedClasses.contains(classElement)) {
       generateFieldInits(classElement, buffer, bodyBuffer);
@@ skipping 386 matching lines @@
       Element isolateMain =
         compiler.isolateLibrary.find(Compiler.START_ROOT_ISOLATE);
       buffer.add(buildIsolateSetup(main, isolateMain));
     } else {
       buffer.add('${namer.isolateAccess(main)}();\n');
     }
   }
 
   String assembleProgram() {
     measure(() {
-      StringBuffer buffer = new StringBuffer();
-      buffer.add('function ${namer.ISOLATE}() {');
-      emitStaticNonFinalFieldInitializations(buffer);
-      buffer.add('}\n\n');
-      emitClasses(buffer);
-      emitStaticFunctions(buffer);
-      emitStaticFunctionGetters(buffer);
-      emitCompileTimeConstants(buffer);
-      emitStaticFinalFieldInitializations(buffer);
-      nativeEmitter.emitDynamicDispatchMetadata(buffer);
-      buffer.add('var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
-      emitMain(buffer);
-      compiler.assembledCode = buffer.toString();
+      mainBuffer.add('function ${namer.ISOLATE}() {');
+      emitStaticNonFinalFieldInitializations(mainBuffer);
+      mainBuffer.add('}\n\n');
+      emitClasses(mainBuffer);
+      emitStaticFunctions(mainBuffer);
+      emitStaticFunctionGetters(mainBuffer);
+      emitCompileTimeConstants(mainBuffer);
+      emitStaticFinalFieldInitializations(mainBuffer);
+      nativeEmitter.emitDynamicDispatchMetadata();
+      mainBuffer.add(
+          'var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
+      nativeEmitter.assembleCode(mainBuffer);
+      emitMain(mainBuffer);
+      compiler.assembledCode = mainBuffer.toString();
     });
     return compiler.assembledCode;
   }
 }