Take inheritance into account when computing the elements accessible by mirrors.

sdk/lib/_internal/compiler/implementation/js_emitter/class_emitter.dart

 // Copyright (c) 2013, 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 ClassEmitter extends CodeEmitterHelper {
   /**
    * Documentation wanted -- johnniwinther
    *
@@ skipping 206 matching lines @@
             }
             int code = getterCode + (setterCode << 2);
             if (code == 0) {
               compiler.internalError(field,
                   'Field code is 0 ($element/$field).');
             } else {
               fieldCode = FIELD_CODE_CHARACTERS[code - FIRST_FIELD_CODE];
             }
           }
           if (backend.isAccessibleByReflection(field)) {
-            reflectionMarker = '-';
-            if (backend.isNeededForReflection(field)) {
-              DartType type = field.type;
-              reflectionMarker = '-${task.metadataEmitter.reifyType(type)}';
-            }
+            DartType type = field.type;
+            reflectionMarker = '-${task.metadataEmitter.reifyType(type)}';
           }
           builder.addField('$fieldName$fieldCode$reflectionMarker');
           fieldsAdded = true;
         }
       });
     }
 
     if (hasMetadata) {
       builder.fieldMetadata = fieldMetadata;
     }
@@ skipping 64 matching lines @@
 
   void emitClassBuilderWithReflectionData(String className,
                                           ClassElement classElement,
                                           ClassBuilder classBuilder,
                                           ClassBuilder enclosingBuilder) {
     var metadata = task.metadataEmitter.buildMetadataFunction(classElement);
     if (metadata != null) {
       classBuilder.addProperty("@", metadata);
     }
 
-    if (backend.isNeededForReflection(classElement)) {
+    if (backend.isAccessibleByReflection(classElement)) {
       Link typeVars = classElement.typeVariables;
       Iterable typeVariableProperties = task.typeVariableHandler
           .typeVariablesOf(classElement).map(js.number);
 
       ClassElement superclass = classElement.superclass;
       bool hasSuper = superclass != null;
       if ((!typeVariableProperties.isEmpty && !hasSuper) ||
           (hasSuper && superclass.typeVariables != typeVars)) {
         classBuilder.addProperty('<>',
             new jsAst.ArrayInitializer.from(typeVariableProperties));
@@ skipping 19 matching lines @@
 
     if (!statics.isEmpty) {
       classBuilder.addProperty('static', new jsAst.ObjectInitializer(statics));
     }
 
     // TODO(ahe): This method (generateClass) should return a jsAst.Expression.
     enclosingBuilder.addProperty(className, classBuilder.toObjectInitializer());
 
     String reflectionName = task.getReflectionName(classElement, className);
     if (reflectionName != null) {
-      if (!backend.isNeededForReflection(classElement)) {
+      if (!backend.isAccessibleByReflection(classElement)) {
         enclosingBuilder.addProperty("+$reflectionName", js.number(0));
       } else {
         List<int> types = <int>[];
         if (classElement.supertype != null) {
           types.add(task.metadataEmitter.reifyType(classElement.supertype));
         }
         for (DartType interface in classElement.interfaces) {
           types.add(task.metadataEmitter.reifyType(interface));
         }
         enclosingBuilder.addProperty("+$reflectionName",
@@ skipping 162 matching lines @@
   void generateGetter(Element member, String fieldName, String accessorName,
                       ClassBuilder builder) {
     String getterName = namer.getterNameFromAccessorName(accessorName);
     ClassElement cls = member.enclosingClass;
     String className = namer.getNameOfClass(cls);
     String receiver = backend.isInterceptorClass(cls) ? 'receiver' : 'this';
     List<String> args = backend.isInterceptedMethod(member) ? ['receiver'] : [];
     task.precompiledFunction.add(
         js('#.prototype.# = function(#) { return #.# }',
            [className, getterName, args, receiver, fieldName]));
-    if (backend.isNeededForReflection(member)) {
+    if (backend.isAccessibleByReflection(member)) {
       task.precompiledFunction.add(
           js('#.prototype.#.${namer.reflectableField} = 1',
               [className, getterName]));
     }
   }
 
   void generateSetter(Element member, String fieldName, String accessorName,
                       ClassBuilder builder) {
     String setterName = namer.setterNameFromAccessorName(accessorName);
     ClassElement cls = member.enclosingClass;
     String className = namer.getNameOfClass(cls);
     String receiver = backend.isInterceptorClass(cls) ? 'receiver' : 'this';
     List<String> args = backend.isInterceptedMethod(member) ? ['receiver'] : [];
     task.precompiledFunction.add(
         // TODO: remove 'return'?
         js('#.prototype.# = function(#, v) { return #.# = v; }',
             [className, setterName, args, receiver, fieldName]));
-    if (backend.isNeededForReflection(member)) {
+    if (backend.isAccessibleByReflection(member)) {
       task.precompiledFunction.add(
           js('#.prototype.#.${namer.reflectableField} = 1',
               [className, setterName]));
     }
   }
 
   void generateReflectionDataForFieldGetterOrSetter(Element member,
                                                     String name,
                                                     ClassBuilder builder,
                                                     {bool isGetter}) {
@@ skipping 42 matching lines @@
       computeTypeVariable =
           js(r'this.$builtinTypeInfo && this.$builtinTypeInfo[#]', index);
     }
     jsAst.Expression convertRtiToRuntimeType =
         namer.elementAccess(backend.findHelper('convertRtiToRuntimeType'));
     builder.addProperty(name,
         js('function () { return #(#) }',
             [convertRtiToRuntimeType, computeTypeVariable]));
   }
 }