dart2js: native classes go through the normal code path.

pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart

 // Copyright (c) 2014, 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 dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 29 matching lines @@
 
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   Set<ClassElement> get neededClasses => task.neededClasses;
   Map<OutputUnit, List<ClassElement>> get outputClassLists
       => task.outputClassLists;
   Map<OutputUnit, List<ConstantValue>> get outputConstantLists
       => task.outputConstantLists;
-  List<ClassElement> get nativeClasses => task.nativeClasses;
   final Map<String, String> mangledFieldNames = <String, String>{};
   final Map<String, String> mangledGlobalFieldNames = <String, String>{};
   final Set<String> recordedMangledNames = new Set<String>();
 
   Map<Class, Map<String, jsAst.Expression>> additionalProperties;
 
   List<TypedefElement> get typedefsNeededForReflection =>
       task.typedefsNeededForReflection;
 
   JavaScriptBackend get backend => compiler.backend;
@@ skipping 380 matching lines @@
           };
         }()
       ''');
     if (compiler.hasIncrementalSupport) {
       result = js(
           r'#.inheritFrom = #', [namer.accessIncrementalHelper, result]);
     }
     return js(r'var inheritFrom = #', [result]);
   }
 
-  jsAst.Statement buildFinishClass() {
+  jsAst.Statement buildFinishClass(bool hasNativeClasses) {
     String specProperty = '"${namer.nativeSpecProperty}"';  // "%"
 
     jsAst.Expression finishedClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
     jsAst.Expression interceptorsByTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
     jsAst.Expression leafTagsAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
 
     return js.statement('''
@@ skipping 86 matching lines @@
                   #interceptorsByTagAccess[tags[i]] = constructor;
                   #leafTagsAccess[tags[i]] = false;
                 }
               }
             }
           }
         }
       }
     }''', {'finishedClassesAccess': finishedClassesAccess,
            'needsMixinSupport': needsMixinSupport,
-           'hasNativeClasses': nativeClasses.isNotEmpty,
+           'hasNativeClasses': hasNativeClasses,
            'nativeSuperclassTagName': embeddedNames.NATIVE_SUPERCLASS_TAG_NAME,
            'interceptorsByTagAccess': interceptorsByTagAccess,
            'leafTagsAccess': leafTagsAccess,
            'allowNativesSubclassing': true});
   }
 
   void emitFinishIsolateConstructorInvocation(CodeOutput output) {
     String isolate = namer.isolateName;
     output.add("$isolate = $finishIsolateConstructorName($isolate)$N");
   }
@@ skipping 798 matching lines @@
 
     ClassBuilder libraryBuilder = getElementDescriptor(libraryElement);
     for (Class cls in library.classes) {
       emitClass(cls, libraryBuilder);
     }
 
     classEmitter.emitFields(library, libraryBuilder, emitStatics: true);
   }
 
   void emitMainOutputUnit(Program program,
-                          Map<OutputUnit, String> deferredLoadHashes,
-                          CodeBuffer nativeBuffer) {
+                          Map<OutputUnit, String> deferredLoadHashes) {
     Fragment mainFragment = program.fragments.first;
     OutputUnit mainOutputUnit = mainFragment.outputUnit;
 
     LineColumnCollector lineColumnCollector;
     List<CodeOutputListener> codeOutputListeners;
     if (generateSourceMap) {
       lineColumnCollector = new LineColumnCollector();
       codeOutputListeners = <CodeOutputListener>[lineColumnCollector];
     }
 
@@ skipping 92 matching lines @@
     emitMangledNames(mainOutput);
 
     checkEverythingEmitted(elementDescriptors.keys);
 
     CodeBuffer libraryBuffer = new CodeBuffer();
     for (LibraryElement library in Elements.sortedByPosition(libraries)) {
       writeLibraryDescriptors(libraryBuffer, library);
       elementDescriptors.remove(library);
     }
 
+    bool hasNativeClasses = program.outputContainsNativeClasses;
     mainOutput
         ..addBuffer(
             jsAst.prettyPrint(
-                getReflectionDataParser(this, backend),
+                getReflectionDataParser(this, backend, hasNativeClasses),
                 compiler))
         ..add(n);
 
     // The argument to reflectionDataParser is assigned to a temporary 'dart'
     // so that 'dart.' will appear as the prefix to dart methods in stack
     // traces and profile entries.
     mainOutput..add('var dart = [$n')
               ..addBuffer(libraryBuffer)
               ..add(']$N')
               ..add('$parseReflectionDataName(dart)$N');
@@ skipping 18 matching lines @@
       outputDeferredMap();
     }
 
     // Static field initializations require the classes and compile-time
     // constants to be set up.
     emitStaticNonFinalFieldInitializations(mainOutput, mainOutputUnit);
     interceptorEmitter.emitMapTypeToInterceptor(mainOutput);
     emitLazilyInitializedStaticFields(mainOutput);
 
     mainOutput.add('\n');
-    mainOutput.addBuffer(nativeBuffer);
 
     metadataEmitter.emitMetadata(mainOutput);
 
     isolateProperties = isolatePropertiesName;
     // The following code should not use the short-hand for the
     // initialStatics.
     mainOutput.add('${namer.currentIsolate}$_=${_}null$N');
 
     emitFinishIsolateConstructorInvocation(mainOutput);
     mainOutput.add(
@@ skipping 213 matching lines @@
         for (LibraryElement library in Elements.sortedByPosition(libraries)) {
           writeLibraryDescriptors(buffer, library);
           elementDescriptors.remove(library);
         }
       }
     }
 
     return emitDeferredCode(program, outputBuffers);
   }
 
-  CodeBuffer buildNativesBuffer(Program program) {
-    // Emit native classes on [nativeBuffer].
-    // TODO(johnniwinther): Avoid creating a [CodeBuffer].
-    final CodeBuffer nativeBuffer = new CodeBuffer();
-
-    if (program.nativeClasses.isEmpty) return nativeBuffer;
-
-
-    addComment('Native classes', nativeBuffer);
-
-    for (Class cls in program.nativeClasses) {
-      assert(cls.isNative);
-      ClassBuilder enclosingBuilder = getElementDescriptor(cls.element);
-      emitClass(cls, enclosingBuilder);
-    }
-
-    nativeEmitter.finishGenerateNativeClasses();
-    nativeEmitter.assembleCode(nativeBuffer);
-
-    return nativeBuffer;
-  }
-
   int emitProgram(ProgramBuilder programBuilder) {
     Program program = programBuilder.buildProgram(
         storeFunctionTypesInMetadata: true);
 
     additionalProperties = program.additionalProperties;
 
     // Shorten the code by using [namer.currentIsolate] as temporary.
     isolateProperties = namer.currentIsolate;
 
     // Emit deferred units first, so we have their hashes.
     // Map from OutputUnit to a hash of its content. The hash uniquely
     // identifies the code of the output-unit. It does not include
     // boilerplate JS code, like the sourcemap directives or the hash
     // itself.
     Map<OutputUnit, String> deferredLoadHashes =
         emitDeferredOutputUnits(program);
-    CodeBuffer nativeBuffer = buildNativesBuffer(program);
-    emitMainOutputUnit(program, deferredLoadHashes, nativeBuffer);
+    emitMainOutputUnit(program, deferredLoadHashes);
 
     if (backend.requiresPreamble &&
         !backend.htmlLibraryIsLoaded) {
       compiler.reportHint(NO_LOCATION_SPANNABLE, MessageKind.PREAMBLE);
     }
     // Return the total program size.
     return outputBuffers.values.fold(0, (a, b) => a + b.length);
   }
 
   String generateSourceMapTag(Uri sourceMapUri, Uri fileUri) {
@@ skipping 279 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }