Implement InstanceMirror.getField/setField (minified).

dart/sdk/lib/_internal/compiler/implementation/js_backend/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 js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 55 matching lines @@
   final CodeBuffer deferredBuffer = new CodeBuffer();
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   final Set<ClassElement> neededClasses = new Set<ClassElement>();
   final List<ClassElement> regularClasses = <ClassElement>[];
   final List<ClassElement> deferredClasses = <ClassElement>[];
   final List<ClassElement> nativeClasses = <ClassElement>[];
   final List<Selector> trivialNsmHandlers = <Selector>[];
+  final Map<String, String> mangledFieldNames = <String, String>{};
 
   // TODO(ngeoffray): remove this field.
   Set<ClassElement> instantiatedClasses;
 
   final List<jsAst.Expression> boundClosures = <jsAst.Expression>[];
 
   JavaScriptBackend get backend => compiler.backend;
 
   String get _ => compiler.enableMinification ? "" : " ";
   String get n => compiler.enableMinification ? "" : "\n";
@@ skipping 1367 matching lines @@
   }
 
   void emitSuper(String superName, ClassBuilder builder) {
     /* Do nothing. */
   }
 
   void emitRuntimeName(String runtimeName, ClassBuilder builder) {
     /* Do nothing. */
   }
 
+  void recordMangledField(Element member,
+                          String accessorName,
+                          String memberName) {
+    String previousName = mangledFieldNames.putIfAbsent(
+        '${namer.getterPrefix}$accessorName',
+        () => memberName);
+    assert(invariant(member, previousName == memberName,
+                     message: '$previousName != ${memberName}'));
+    previousName = mangledFieldNames.putIfAbsent(
+        '${namer.setterPrefix}$accessorName',
+        () => '${memberName}=');
+    assert(invariant(member, previousName == '${memberName}=',
+                     message: '$previousName != ${memberName}='));
+  }
+
   /// Returns `true` if fields added.
   bool emitClassFields(ClassElement classElement,
                        ClassBuilder builder,
                        String superName,
                        { bool classIsNative: false }) {
     assert(superName != null);
     String separator = '';
     String nativeName = namer.getPrimitiveInterceptorRuntimeName(classElement);
     StringBuffer buffer = new StringBuffer();
     if (nativeName != null) {
@@ skipping 20 matching lines @@
       if (!classIsNative || needsAccessor) {
         buffer.write(separator);
         separator = ',';
         if (compiler.mirrorsEnabled) {
           var metadata = buildMetadataFunction(member);
           fieldMetadata.add(metadata);
           if (metadata != null) {
             hasMetadata = true;
           }
         }
+        if (compiler.mirrorsEnabled) {
+          recordMangledField(member, accessorName, member.name.slowToString());
+        }
         if (!needsAccessor) {
           // Emit field for constructor generation.
           assert(!classIsNative);
           buffer.write(name);
         } else {
           // Emit (possibly renaming) field name so we can add accessors at
           // runtime.
           buffer.write(accessorName);
           if (name != accessorName) {
             buffer.write(':$name');
@@ skipping 1567 matching lines @@
       classesCollector = 'classesCollector should not be used from now on';
 
       emitStaticFunctions(mainBuffer);
 
       if (!libraryBuffers.isEmpty) {
         var oldClassesCollector = classesCollector;
         classesCollector = r"$$";
         if (compiler.enableMinification) {
           mainBuffer.write(';');
         }
+        if (!mangledFieldNames.isEmpty) {
+          var keys = mangledFieldNames.keys.toList();
+          keys.sort();
+          var properties = [];
+          for (String key in keys) {
+            var value = js.string('${mangledFieldNames[key]}');
+            properties.add(new jsAst.Property(js.string(key), value));
+          }
+          var map = new jsAst.ObjectInitializer(properties);
+          mainBuffer.write(
+              jsAst.prettyPrint(
+                  js('init.mangledNames = #', map).toStatement(), compiler));
+          if (compiler.enableMinification) {
+            mainBuffer.write(';');
+          }
+        }
         mainBuffer
             ..write(getReflectionDataParser())
             ..write('([$n');
         emitDeferredPreambleWhenEmpty(deferredBuffer);
         deferredBuffer.add('\$\$$_=$_{};$n');
 
         deferredBuffer
             ..write(getReflectionDataParser())
             ..write('([$n');
         var sortedLibraries = Elements.sortedByPosition(libraryBuffers.keys);
@@ skipping 249 matching lines @@
 
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;