dart2js: remove additionalProperties and store it directly as nativeBlob.

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 33 matching lines @@
   String classesCollector;
   Set<ClassElement> get neededClasses => task.neededClasses;
   Map<OutputUnit, List<ClassElement>> get outputClassLists
       => task.outputClassLists;
   Map<OutputUnit, List<ConstantValue>> get outputConstantLists
       => task.outputConstantLists;
   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;
   TypeVariableHandler get typeVariableHandler => backend.typeVariableHandler;
 
   String get _ => space;
   String get space => compiler.enableMinification ? "" : " ";
   String get n => compiler.enableMinification ? "" : "\n";
   String get N => compiler.enableMinification ? "\n" : ";\n";
@@ skipping 647 matching lines @@
              cspPrecompiledConstructorNamesFor(outputUnit))]);
   }
 
   void emitClass(Class cls, ClassBuilder enclosingBuilder) {
     ClassElement classElement = cls.element;
     compiler.withCurrentElement(classElement, () {
       if (compiler.hasIncrementalSupport) {
         ClassBuilder cachedBuilder =
             cachedClassBuilders.putIfAbsent(classElement, () {
               ClassBuilder builder = new ClassBuilder(classElement, namer);
-              classEmitter.emitClass(
-                  cls, builder, additionalProperties[cls]);
+              classEmitter.emitClass(cls, builder);
               return builder;
             });
         invariant(classElement, cachedBuilder.fields.isEmpty);
         invariant(classElement, cachedBuilder.superName == null);
         invariant(classElement, cachedBuilder.functionType == null);
         invariant(classElement, cachedBuilder.fieldMetadata == null);
         enclosingBuilder.properties.addAll(cachedBuilder.properties);
       } else {
-        classEmitter.emitClass(
-            cls, enclosingBuilder, additionalProperties[cls]);
+        classEmitter.emitClass(cls, enclosingBuilder);
       }
     });
   }
 
   void emitStaticFunctions(Iterable<Method> staticFunctions) {
     if (staticFunctions == null) return;
     // We need to filter out null-elements for the interceptors.
     Iterable<Element> elements = staticFunctions
         .where((Method method) => method.element != null)
         .map((Method method) => method.element);
@@ skipping 1014 matching lines @@
       }
     }
 
     return emitDeferredCode(program, outputBuffers);
   }
 
   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);
@@ skipping 290 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }