Implement reflecting on uninstantiated classes.

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 595 matching lines @@
            * 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,
+              compiler.mirrorsEnabled,
               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]')
             ])
@@ skipping 13 matching lines @@
             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('var constructor = defineClass(name, cls, fields, desc)'),
-          optional(compiler.mirrorSystemClass != null,
+          optional(compiler.mirrorsEnabled,
                    js('constructor["${namer.metadataField}"] = desc')),
           js('isolateProperties[cls] = constructor'),
           js.if_('supr', js('pendingClasses[cls] = supr'))
         ])
       ]),
 
       js('var finishedClasses = {}'),
 
       buildFinishClass(),
     ];
@@ skipping 802 matching lines @@
                                     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) {
+        if (compiler.mirrorsEnabled) {
           var metadata = buildMetadataFunction(member);
           fieldMetadata.add(metadata);
           if (metadata != null) {
             hasMetadata = true;
           }
         }
         if (!needsAccessor) {
           // Emit field for constructor generation.
           assert(!classIsNative);
           buffer.write(name);
@@ skipping 1481 matching lines @@
     if (compiler.enableMinification) buffer.write('\n');
   }
 
   /// The metadata function returns the metadata associated with
   /// [element] in generated code.  The metadata needs to be wrapped
   /// in a function as it refers to constants that may not have been
   /// constructed yet.  For example, a class is allowed to be
   /// annotated with itself.  The metadata function is used by
   /// mirrors_patch to implement DeclarationMirror.metadata.
   jsAst.Fun buildMetadataFunction(Element element) {
-    if (compiler.mirrorSystemClass == null) return null;
+    if (!compiler.mirrorsEnabled) return null;
     var metadata = [];
     Link link = element.metadata;
     // TODO(ahe): Why is metadata sometimes null?
     if (link != null) {
       for (; !link.isEmpty; link = link.tail) {
         metadata.add(constantReference(link.head.value));
       }
     }
     if (metadata.isEmpty) return null;
     return js.fun([], [js.return_(new jsAst.ArrayInitializer.from(metadata))]);
@@ skipping 334 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].
 """;