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

sdk/lib/_internal/compiler/implementation/compiler.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;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 412 matching lines @@
     return new Future.value();
   }
 
   /// Called by [MirrorUsageAnalyzerTask] after it has merged all @MirrorsUsed
   /// annotations. The arguments corresponds to the unions of the corresponding
   /// fields of the annotations.
   void registerMirrorUsage(Set<String> symbols,
                            Set<Element> targets,
                            Set<Element> metaTargets) {}
 
-  /// Returns true if this element should be retained for reflection even if it
-  /// would normally be tree-shaken away.
-  bool isNeededForReflection(Element element) => false;
+  /// Returns true if this element needs reflection information at runtime.
+  bool isAccessibleByReflection(Element element) => true;
+  /// Returns true if this element is covered by a mirrorsUsed annotation but

[Johnni Winther, 2014/06/27 07:43:00]

Add an empty line before doc comments.

[herhut, 2014/06/27 12:34:35]

Done.

+  /// is ok to be treeshaken away.

[Johnni Winther, 2014/06/27 07:43:00]

Add an example of how this is sound.

[floitsch, 2014/06/27 08:59:15]

but might be ok to be treeshaken away.

[herhut, 2014/06/27 12:34:35]

Done.

[herhut, 2014/06/27 12:34:35]

Done.

+  bool referencedFromMirrorSystem(Element element, [recursive]) => false;
+  /// Returns true if this element has to be enqueued due to
+  /// mirror usage. Might be a subset of the above.
+  bool requiredByMirrorSystem(Element element) => false;

[Johnni Winther, 2014/06/27 07:43:00]

Give an example.

[herhut, 2014/06/27 12:34:35]

Done.

 
   /// Returns true if global optimizations such as type inferencing
   /// can apply to this element. One category of elements that do not
   /// apply is runtime helpers that the backend calls, but the
   /// optimizations don't see those calls.
   bool canBeUsedForGlobalOptimizations(Element element) => true;
 
   /// Called when [enqueuer]'s queue is empty, but before it is closed.
   /// This is used, for example, by the JS backend to enqueue additional
-  /// elements needed for reflection.
-  void onQueueEmpty(Enqueuer enqueuer) {}
+  /// elements needed for reflection. [recentClasses] is a collection of
+  /// all classes added since the last call to onQueueEmpty. A return value

[Johnni Winther, 2014/06/27 07:43:00]

'added' -> 'added to the set of instantiation classes'?

[herhut, 2014/06/27 12:34:35]

seen for the first time by the enqueuer....

+  /// of [true] indicates that recentClasses has been processed and its
+  /// elements do not need to be seen in the next round. When [false] is
+  /// returned, [onQueueEmpty] will be called again and [recentClasses]
+  /// will be a superset of the current value.

[Johnni Winther, 2014/06/27 07:43:00]

When is this needed?

[herhut, 2014/06/27 12:34:35]

This allows each step in onQueueEmpty to abort processing and return to
processing the queue before all recents have been processed. Used by the
CustomTags analysis.

+  bool onQueueEmpty(Enqueuer enqueuer, Iterable<ClassElement> recentClasses) {}

[floitsch, 2014/06/27 08:59:15]

I don't like the name "onX" is something that allows me to register something
for when "X" happens.
I prefer notifyX.

(Note: this is not the only place, so don't necessarily worry for this CL).

[karlklose, 2014/06/27 09:35:28]

For me onX is something that allows me to do something when "X" happens, so I
think it fits.

I would like to find a better name for onX and registerX, but I dislike notifyX
because it is the wrong verb: we do not want the receiver to notify the "X"
(think of notifyListeners).

[floitsch, 2014/06/27 12:05:38]

That's not how it is used in most libraries. For example: domElement.onClick

[herhut, 2014/06/27 12:34:35]

This needs a more global fix, so not in this CL...

[Johnni Winther, 2014/06/27 14:22:30]

The `domElement.onClick` is a short-hand for getting of the "onClickStream"
property on which you register a listener. So the API has made
`domElement.onClick.listen(...)` the Dart-way of saying
"domElement.registerOnClickListener(...)". Thus 'onClick' is still the name of
the event that you want to provide a callback for.

In other words, I think the API naming convention has cluttered the terminology
of two abstractions, the observer and the observable, by giving the observable
the name for the observer.

Maybe we are left with names like 'callbackForOnQueueEmpty'.

 
   /// Called after [element] has been resolved.
   // TODO(johnniwinther): Change [TreeElements] to [Registry] or a dependency
   // node. [elements] is currently unused by the implementation.
   void onElementResolved(Element element, TreeElements elements) {}
 
   // Does this element belong in the output
   bool shouldOutput(Element element) => true;
 }
 
@@ skipping 1560 matching lines @@
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }
 
 /// Information about suppressed warnings and hints for a given library.
 class SuppressionInfo {
   int warnings = 0;
   int hints = 0;
 }