Implement metadata for instance fields.

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 594 matching lines @@
           /* The 'fields' are either a constructor function or a
            * string encoding fields, constructor and superclass.  Get
            * the superclass and the fields in the format
            *   '[name/]Super;field1,field2'
            * from the null-string property on the descriptor.
            * The 'name/' is optional and contains the name that should be used
            * when printing the runtime type string.  It is used, for example, to
            * print the runtime type JSInt as 'int'.
            */
           js('var classData = desc[""], supr, name = cls, fields = classData'),
+          optional(
+              compiler.mirrorSystemClass != null,
+              js.if_('typeof classData == "object" && '
+                     'classData instanceof Array',
+                     [js('classData = fields = classData[0]')])),
+
           js.if_('typeof classData == "string"', [
             js('var split = classData.split("/")'),
             js.if_('split.length == 2', [
               js('name = split[0]'),
               js('fields = split[1]')
             ])
           ]),
 
           js.if_('typeof fields == "string"', [
             js('var s = fields.split(";")'),
             js('fields = s[1] == "" ? [] : s[1].split(",")'),
             js('supr = s[0]'),
           ], /* else */ [
             js('supr = desc.super'),
             js.if_(r'!!desc.$name', js(r'name = desc.$name'))
           ]),
 
           optional(needsMixinSupport, js.if_('supr && supr.indexOf("+") > 0', [
             js('s = supr.split("+")'),
             js('supr = s[0]'),
             js('var mixin = collectedClasses[s[1]]'),
             js.forIn('d', 'mixin', [
               js.if_('hasOwnProperty.call(mixin, d)'
                      '&& !hasOwnProperty.call(desc, d)',
                 js('desc[d] = mixin[d]'))
             ]),
           ])),
 
-          js('isolateProperties[cls] = defineClass(name, cls, fields, desc)'),
+          js('var constructor = defineClass(name, cls, fields, desc)'),
+          optional(compiler.mirrorSystemClass != null,
+                   js('constructor["${namer.metadataField}"] = desc')),
+          js('isolateProperties[cls] = constructor'),
           js.if_('supr', js('pendingClasses[cls] = supr'))
         ])
       ]),
 
       js('var finishedClasses = {}'),
 
       buildFinishClass(),
     ];
 
     addTrivialNsmHandlers(statements);
@@ skipping 782 matching lines @@
     assert(superName != null);
     String separator = '';
     String nativeName = namer.getPrimitiveInterceptorRuntimeName(classElement);
     StringBuffer buffer = new StringBuffer();
     if (nativeName != null) {
       buffer.write('$nativeName/');
     }
     buffer.write('$superName;');
     int bufferClassLength = buffer.length;
 
+    var fieldMetadata = [];
+    bool hasMetadata = false;
+
     visitClassFields(classElement, (Element member,
                                     String name,
                                     String accessorName,
                                     bool needsGetter,
                                     bool needsSetter,
                                     bool needsCheckedSetter) {
       // Ignore needsCheckedSetter - that is handled below.
       bool needsAccessor = (needsGetter || needsSetter);
       // We need to output the fields for non-native classes so we can auto-
       // generate the constructor.  For native classes there are no
       // constructors, so we don't need the fields unless we are generating
       // accessors at runtime.
       if (!classIsNative || needsAccessor) {
         buffer.write(separator);
         separator = ',';
+        if (compiler.mirrorSystemClass != null) {
+          var metadata = buildMetadataFunction(member);
+          fieldMetadata.add(metadata);
+          if (metadata != null) {
+            hasMetadata = true;
+          }
+        }
         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 23 matching lines @@
             assert(setterCode != 0);
           }
           int code = getterCode + (setterCode << 2);
           buffer.write(FIELD_CODE_CHARACTERS[code - FIRST_FIELD_CODE]);
         }
       }
     });
 
     bool fieldsAdded = buffer.length > bufferClassLength;
     String compactClassData = buffer.toString();
-    builder.addProperty('', js.string(compactClassData));
+    jsAst.Expression classDataNode = js.string(compactClassData);
+    if (hasMetadata) {
+      fieldMetadata.insert(0, classDataNode);
+      classDataNode = new jsAst.ArrayInitializer.from(fieldMetadata);
+    }
+    builder.addProperty('', classDataNode);
     return fieldsAdded;
   }
 
   void emitClassGettersSetters(ClassElement classElement,
                                ClassBuilder builder) {
 
     visitClassFields(classElement, (Element member,
                                     String name,
                                     String accessorName,
                                     bool needsGetter,
@@ skipping 1760 matching lines @@
           if (!hasOwnProperty.call(element, prop)) continue;
           if (prop.substring(0, 1) == "@" && prop != "@") {
             newDesc[prop.substring(1)]["${namer.metadataField}"] ='''
 '''element[prop];
           } else {
             newDesc[prop] = element[prop];
           }
         }
         $classesCollector[property] = newDesc;
         classes.push(property);
-        classes.push(element[""]);
       }
     }
     libraries.push([name, uri, classes, functions, metadata]);
   }
 })''';
   }
 }
 
 const String GENERATED_BY = """
 // Generated by dart2js, the Dart to JavaScript compiler.
 """;
 
 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].
 """;