dart2js: remove additionalProperties and store it directly as nativeBlob.

pkg/compiler/lib/src/js_emitter/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.
 
 part of dart2js.js_emitter;
 
 class NativeEmitter {
 
   final Map<Element, ClassBuilder> cachedBuilders;
 
@@ skipping 30 matching lines @@
     Element element = backend.findHelper('defineProperty');
     return emitterTask.staticFunctionAccess(element);
   }
 
   /**
    * Prepares native classes for emission. Returns the unneeded classes.
    *
    * Removes trivial classes (that can be represented by a super type) and
    * generates properties that have to be added to classes (native or not).
    *
+   * Updates the `nativeBlob` field of the given classes. This data
+   * must be emitted with the corresponding classes.
+   *
    * The interceptors are filtered to avoid emitting trivial interceptors.  For
    * example, if the program contains no code that can distinguish between the
    * numerous subclasses of `Element` then we can pretend that `Element` is a
    * leaf class, and all instances of subclasses of `Element` are instances of
    * `Element`.
    *
    * There is also a performance benefit (in addition to the obvious code size
    * benefit), due to how [getNativeInterceptor] works.  Finding the interceptor
    * of a leaf class in the hierarchy is more efficient that a non-leaf, so it
    * improves performance when more classes can be treated as leaves.
    *
    * [classes] contains native classes, mixin applications, and user subclasses
    * of native classes.
-   *
-   * [allAdditionalProperties] is used to collect properties that are pushed up
-   * from the above optimizations onto a non-native class, e.g, `Interceptor`.
    */
-  Set<Class> prepareNativeClasses(
-      List<Class> classes,
-      Map<Class, Map<String, jsAst.Expression>> allAdditionalProperties) {
+  Set<Class> prepareNativeClasses(List<Class> classes) {
     assert(classes.every((Class cls) => cls != null));
 
     hasNativeClasses = classes.isNotEmpty;
 
     // Compute a pre-order traversal of the subclass forest.  We actually want a
     // post-order traversal but it is easier to compute the pre-order and use it
     // in reverse.
     List<Class> preOrder = <Class>[];
     Set<Class> seen = new Set<Class>();
 
@@ skipping 120 matching lines @@
         if (nonleafStr != '') {
           sb..write(';')..write(nonleafStr);
         }
         if (extensions != null) {
           sb..write(';')
             ..writeAll(extensions.map((Class cls) => cls.name), '|');
         }
         String encoding = sb.toString();
 
         if (cls.isNative || encoding != '') {
-          Map<String, jsAst.Expression> properties =
-              allAdditionalProperties.putIfAbsent(cls,
-                  () => new Map<String, jsAst.Expression>());
-          properties[backend.namer.nativeSpecProperty] = js.string(encoding);
+          assert(cls.nativeBlob == null);
+          cls.nativeBlob = encoding;
         }
       }
       generateClassInfo(jsInterceptorClass);
       for (Class cls in classes) {
         if (!cls.isNative || neededClasses.contains(cls)) {
           generateClassInfo(cls);
         }
       }
     }
 
@@ skipping 195 matching lines @@
         targetOutput.add(';');
       }
       targetOutput.addBuffer(jsAst.prettyPrint(
           new jsAst.ExpressionStatement(init), compiler));
       targetOutput.add('\n');
     }
 
     targetOutput.add('\n');
   }
 }