Members and comments inherited in dartdoc.

pkg/dartdoc/lib/mirrors_util.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.
 
 #library('mirrors.util');
 
 // TODO(rnystrom): Use "package:" URL (#4968).
 #import('mirrors.dart');
 #import('../../../lib/compiler/implementation/util/characters.dart');
 
@@ skipping 12 matching lines @@
     for (InterfaceMirror otherType in library.types.getValues()) {
       var superClass = otherType.superclass;
       if (superClass !== null) {
         superClass = superClass.declaration;
         if (type.library === superClass.library) {
           if (superClass == type) {
              subtypes.add(otherType);
           }
         }
       }
-      final superInterfaces = otherType.interfaces.getValues();
+      final superInterfaces = otherType.interfaces;
       for (InterfaceMirror superInterface in superInterfaces) {
         superInterface = superInterface.declaration;
         if (type.library === superInterface.library) {
           if (superInterface == type) {
             subtypes.add(otherType);
           }
         }
       }
     }
   });
   return subtypes;
 }
 
-/**
- * Finds the mirror in [map] by the simple name [name]. If [constructorName] or
- * [operatorName] is provided, a constructor/operator method by that name is
- * returned.
- */
-Mirror findMirror(Map<Object,Mirror> map, String name,
-                  [String constructorName, String operatorName]) {
-  var foundMirror = null;
-  map.forEach((_, Mirror mirror) {
-    if (mirror.simpleName == name) {
-      if (constructorName !== null) {
-        if (mirror is MethodMirror &&
-            constructorName == mirror.constructorName) {
-          foundMirror = mirror;
-        }
-      } else if (operatorName !== null) {
-        if (mirror is MethodMirror &&
-            operatorName == mirror.operatorName) {
-          foundMirror = mirror;
-        }
-      } else {
-        foundMirror = mirror;
-      }
-    }
-  });
-  return foundMirror;
-}
-
 LibraryMirror findLibrary(MemberMirror member) {
   ObjectMirror owner = member.surroundingDeclaration;
   if (owner is LibraryMirror) {
     return owner;
   } else if (owner is TypeMirror) {
     return owner.library;
   }
   throw new Exception('Unexpected owner: ${owner}');
 }
 
 
 /**
  * Returns the column of the start of a location.
  */
 int getLocationColumn(Location location) {
   String text = location.source.text;
   int index = location.start-1;
   var column = 0;
   while (0 <= index && index < text.length) {
     var charCode = text.charCodeAt(index);
     if (charCode == $CR || charCode == $LF) {
       break;
     }
     index--;
     column++;
   }
   return column;
 }
+
+class HierarchyIterable implements Iterable<InterfaceMirror> {

[Lasse Reichstein Nielsen, 2012/10/04 07:41:19]

Consider whether Iterable is necessary in the name. Maybe it is.

[Johnni Winther, 2012/10/04 12:46:21]

I can't think of a sensible name without Iterable.

+  final bool includeType;
+  final InterfaceMirror type;
+
+  HierarchyIterable(this.type, {bool includeType})
+      : this.includeType = includeType;
+
+  Iterator<InterfaceMirror> iterator() =>
+      new HierarchyIterator(type, includeType: includeType);
+}
+
+/**
+ * [HierarchyIterator] iterates through the class hierarchy of the provided
+ * type.
+ *
+ * First is the superclass relation is traversed, next the superinterface
+ * relation and finally is [Object] visited.

[Lasse Reichstein Nielsen, 2012/10/04 07:41:19]

Why do you mention Object explicitly? It is in the superinterfaces and
superclass relation of any class, even if it's implicitly, so it should be hit
by the earlier traversal.
Or is this only traversing the *declared* type relations (explicit
extends/implements classes)?
What is traversal order? Depth first or breadth first?(The queue suggests
breadth first).
If a type is implemented more than once, is it encountered more than once?
(Please document).

[Johnni Winther, 2012/10/04 12:46:21]

Done.

+ */
+class HierarchyIterator implements Iterator<InterfaceMirror> {
+  final Queue<InterfaceMirror> queue = new Queue<InterfaceMirror>();
+  InterfaceMirror object;
+
+  HierarchyIterator(InterfaceMirror type, {bool includeType}) {
+    if (includeType) {
+      queue.add(type);
+    } else {
+      push(type);
+    }
+  }
+
+  InterfaceMirror push(InterfaceMirror type) {
+    if (type.superclass !== null) {
+      if (type.superclass.isObject) {
+        object = type.superclass;
+      } else {
+        queue.addFirst(type.superclass);
+      }
+    }
+    queue.addAll(type.interfaces);
+    return type;
+  }
+
+  InterfaceMirror next() {
+    InterfaceMirror type;
+    if (queue.isEmpty()) {
+      if (object === null) {
+        throw new NoMoreElementsException();
+      }
+      type = object;
+      object = null;
+      return type;
+    } else {
+      return push(queue.removeFirst());
+    }
+  }
+
+  bool hasNext() => !queue.isEmpty() || object !== null;
+}