Export members that are part of the runQuery result

pkg/smoke/lib/codegen/recorder.dart

 // Copyright (c) 2014, 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.
 
 /// Records accesses to Dart program declarations and generates code that will
 /// allow to do the same accesses at runtime using `package:smoke/static.dart`.
 /// Internally, this library relies on the `analyzer` to extract data from the
 /// program, and then uses [SmokeCodeGenerator] to produce the code needed by
 /// the smoke system.
 ///
@@ skipping 51 matching lines @@
     }
     if (!baseType.type.isObject) generator.addParent(_typeFor(type), baseId);
   }
 
   TypeIdentifier _typeFor(Element type) => new TypeIdentifier(
       type.library == null ? 'dart:core' : importUrlFor(type.library),
       type.displayName);
 
   /// Adds any declaration and superclass information that is needed to answer a
   /// query on [type] that matches [options]. Also adds symbols, getters, and
-  /// setters if [includeAccessors] is true.
+  /// setters if [includeAccessors] is true. If [results] is not null, it will
+  /// be filled up with the members that match the query.
   void runQuery(ClassElement type, QueryOptions options,
-      {bool includeAccessors: true}) {
+      {bool includeAccessors: true, List results}) {
     if (type.type.isObject) return; // We don't include Object in query results.
     var id = _typeFor(type);
     var parent = type.supertype != null ? type.supertype.element : null;
     if (options.includeInherited && parent != null &&
         parent != options.includeUpTo) {
       lookupParent(type);
       runQuery(parent, options, includeAccessors: includeAccessors);
       var parentId = _typeFor(parent);
       for (var m in type.mixins) {
         var mixinClass = m.element;
         var mixinId = _mixins[parentId][mixinClass];
-        _runQueryInternal(mixinClass, mixinId, options, includeAccessors);
+        _runQueryInternal(
+            mixinClass, mixinId, options, includeAccessors, results);
         parentId = mixinId;
       }
     }
-    _runQueryInternal(type, id, options, includeAccessors);
+    _runQueryInternal(type, id, options, includeAccessors, results);
   }
 
   /// Helper for [runQuery]. This runs the query only on a specific [type],
   /// which could be a class or a mixin labeled by [id].
   // TODO(sigmund): currently we materialize mixins in smoke/static.dart,
   // we should consider to include the mixin declaration information directly,
   // and remove the duplication we have for mixins today.
   void _runQueryInternal(ClassElement type, TypeIdentifier id,
-      QueryOptions options, bool includeAccessors) {
+      QueryOptions options, bool includeAccessors, List results) {
 
     skipBecauseOfAnnotations(Element e) {
       if (options.withAnnotations == null) return false;
       return !_matchesAnnotation(e.metadata, options.withAnnotations);
     }
 
     if (options.includeFields) {
       for (var f in type.fields) {
         if (f.isStatic) continue;
         if (f.isSynthetic) continue; // exclude getters
         if (options.excludeFinal && f.isFinal) continue;
         var name = f.displayName;
         if (options.matches != null && !options.matches(name)) continue;
         if (skipBecauseOfAnnotations(f)) continue;
+        if (results != null) results.add(f);
         generator.addDeclaration(id, name, _typeFor(f.type.element),
             isField: true, isFinal: f.isFinal,
             annotations: _copyAnnotations(f));
         if (includeAccessors) _addAccessors(name, !f.isFinal);
       }
     }
 
     if (options.includeProperties) {
       for (var a in type.accessors) {
         if (a is! PropertyAccessorElement) continue;
         if (a.isStatic || !a.isGetter) continue;
         var v = a.variable;
         if (v is FieldElement && !v.isSynthetic) continue; // exclude fields
         if (options.excludeFinal && v.isFinal) continue;
         var name = v.displayName;
         if (options.matches != null && !options.matches(name)) continue;
         if (skipBecauseOfAnnotations(a)) continue;
+        if (results != null) results.add(a);
         generator.addDeclaration(id, name, _typeFor(a.type.returnType.element),
             isProperty: true, isFinal: v.isFinal,
             annotations: _copyAnnotations(a));
         if (includeAccessors) _addAccessors(name, !v.isFinal);
       }
     }
 
     if (options.includeMethods) {
       for (var m in type.methods) {
         if (m.isStatic) continue;
         var name = m.displayName;
         if (options.matches != null && !options.matches(name)) continue;
         if (skipBecauseOfAnnotations(m)) continue;
+        if (results != null) results.add(m);
         generator.addDeclaration(id, name,
             new TypeIdentifier('dart:core', 'Function'), isMethod: true,
             annotations: _copyAnnotations(m));
         if (includeAccessors) _addAccessors(name, false);
       }
     }
   }
 
   /// Adds the declaration of [name] if it was found in [type]. If [recursive]
   /// is true, then we continue looking up [name] in the parent classes until we
@@ skipping 233 matching lines @@
       this.includeInherited: true,
       this.includeUpTo: null,
       this.excludeFinal: false,
       this.includeMethods: false,
       this.withAnnotations: null,
       this.matches: null});
 }
 
 /// Predicate that tells whether [name] should be included in query results.
 typedef bool NameMatcher(String name);