pkg/docgen: continue the refactoring

pkg/docgen/lib/src/models.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.
 
 library docgen.models;
 
 import 'dart:io';
 
 import 'package:markdown/markdown.dart' as markdown;
 
 import '../../../../sdk/lib/_internal/compiler/implementation/mirrors/source_mirrors.dart';
 import '../../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors_util.dart'
     as dart2js_util;
 import '../../../../sdk/lib/_internal/compiler/implementation/mirrors/dart2js_mirrors.dart'
     as dart2js_mirrors;
 
 import 'library_helpers.dart';
 import 'mdn.dart';
 import 'model_helpers.dart';
 import 'package_helpers.dart';
 
 /// Docgen representation of an item to be documented, that wraps around a
 /// dart2js mirror.
 abstract class MirrorBased<TMirror extends DeclarationMirror> {
   /// The original dart2js mirror around which this object wraps.
   TMirror get mirror;
+
+  /// Return an informative [Object.toString] for debugging.
+  String toString() => "${super.toString()} - $mirror";

[Emily Fortuna, 2014/04/02 16:33:49]

I found printing out dart2js_util.qualifiedNameOf(mirror) to be pretty
indispensable for debugging as well, especially with re-export

[kevmoo, 2014/04/02 16:35:14]

I'll keep that in mind for future hacks here. :-)

 }
 
 /// A Docgen wrapper around the dart2js mirror for a generic type.
 class Generic extends MirrorBased<TypeVariableMirror> {
   final TypeVariableMirror mirror;
 
   Generic(this.mirror);
 
   Map toMap() => {
     'name': dart2js_util.nameOf(mirror),
     'type': dart2js_util.qualifiedNameOf(mirror.upperBound)
   };
 }
 
 /// For types that we do not explicitly create or have not yet created in our
 /// entity map (like core types).
 class DummyMirror implements Indexable {
-  DeclarationMirror mirror;
+  final DeclarationMirror mirror;
   /// The library that contains this element, if any. Used as a hint to help
   /// determine which object we're referring to when looking up this mirror in
   /// our map.
-  Indexable owner;
+  final Indexable owner;
   DummyMirror(this.mirror, [this.owner]);
 
   String get docName {
     if (mirror == null) return '';
     if (mirror is LibraryMirror) {
       return dart2js_util.qualifiedNameOf(mirror).replaceAll('.','-');
     }
     var mirrorOwner = mirror.owner;
     if (mirrorOwner == null) return dart2js_util.qualifiedNameOf(mirror);
     var simpleName = dart2js_util.nameOf(mirror);
@@ skipping 36 matching lines @@
 /// These are items that refer to concrete entities (a Class, for example,
 /// but not a Type, which is a "pointer" to a class) that we wish to be
 /// globally resolvable. This includes things such as class methods and
 /// variables, but parameters for methods are not "Indexable" as we do not want
 /// the user to be able to search for a method based on its parameter names!
 /// The set of indexable items also includes Typedefs, since the user can refer
 /// to them as concrete entities in a particular scope.
 abstract class Indexable<TMirror extends DeclarationMirror>
     extends MirrorBased<TMirror> {
 
-
-  Library get _owningLibrary => owner._owningLibrary;
+  Library get owningLibrary => owner.owningLibrary;
 
   String get qualifiedName => fileName;
   final TMirror mirror;
   final bool isPrivate;
   /// The comment text pre-resolution. We keep this around because inherited
   /// methods need to resolve links differently from the superclass.
   String _unresolvedComment = '';
 
   Indexable(TMirror mirror)
       : this.mirror = mirror,
@@ skipping 132 matching lines @@
     var commentText = _commentText;
     _unresolvedComment = commentText;
 
     var linkResolver = (name) => resolvingScope.fixReference(name);
     commentText = commentText == null ? '' :
         markdown.markdownToHtml(commentText.trim(), linkResolver: linkResolver,
             inlineSyntaxes: MARKDOWN_SYNTAXES);
     return commentText;
   }
 
-  /// Returns a map of [Variable] objects constructed from [mirrorMap].
-  /// The optional parameter [containingLibrary] is contains data for variables
-  /// defined at the top level of a library (potentially for exporting
-  /// purposes).
-  Map<String, Variable> _createVariables(Iterable<VariableMirror> mirrors,
-      Indexable owner) {
-    var data = {};
-    // TODO(janicejl): When map to map feature is created, replace the below
-    // with a filter. Issue(#9590).
-    mirrors.forEach((dart2js_mirrors.Dart2JsFieldMirror mirror) {
-      if (includePrivateMembers || !isHidden(mirror)) {
-        var mirrorName = dart2js_util.nameOf(mirror);
-        data[mirrorName] = new Variable(mirrorName, mirror, owner);
-      }
-    });
-    return data;
-  }
-
-  /// Returns a map of [Method] objects constructed from [mirrorMap].
-  /// The optional parameter [containingLibrary] is contains data for variables
-  /// defined at the top level of a library (potentially for exporting
-  /// purposes).
-  Map<String, Method> _createMethods(Iterable<MethodMirror> mirrors,
-      Indexable owner) {
-    var group = new Map<String, Method>();
-    mirrors.forEach((MethodMirror mirror) {
-      if (includePrivateMembers || !mirror.isPrivate) {
-        group[dart2js_util.nameOf(mirror)] = new Method(mirror, owner);
-      }
-    });
-    return group;
-  }
-
-  /// Returns a map of [Parameter] objects constructed from [mirrorList].
-  Map<String, Parameter> _createParameters(List<ParameterMirror> mirrorList,
-      Indexable owner) {
-    var data = {};
-    mirrorList.forEach((ParameterMirror mirror) {
-      data[dart2js_util.nameOf(mirror)] =
-          new Parameter(mirror, owner._owningLibrary);
-    });
-    return data;
-  }
-
-  /// Returns a map of [Generic] objects constructed from the class mirror.
-  Map<String, Generic> _createGenerics(TypeMirror mirror) {
-    return new Map.fromIterable(mirror.typeVariables,
-        key: (e) => dart2js_util.nameOf(e),
-        value: (e) => new Generic(e));
-  }
-
-  /// Return an informative [Object.toString] for debugging.
-  String toString() => "${super.toString()}(${name.toString()})";
-
   /// Return a map representation of this type.
   Map toMap();
 
-
   /// Expand the method map [mapToExpand] into a more detailed map that
   /// separates out setters, getters, constructors, operators, and methods.
   Map _expandMethodMap(Map<String, Method> mapToExpand) => {
     'setters': recurseMap(filterMap(mapToExpand,
         (key, val) => val.mirror.isSetter)),
     'getters': recurseMap(filterMap(mapToExpand,
         (key, val) => val.mirror.isGetter)),
     'constructors': recurseMap(filterMap(mapToExpand,
         (key, val) => val.mirror.isConstructor)),
     'operators': recurseMap(filterMap(mapToExpand,
@@ skipping 19 matching lines @@
   /// Top-level variables in the library.
   Map<String, Variable> variables;
 
   /// Top-level functions in the library.
   Map<String, Method> functions;
 
   String packageName = '';
   bool _hasBeenCheckedForPackage = false;
   String packageIntro;
 
-  Library get _owningLibrary => this;
+  Library get owningLibrary => this;
 
   /// Returns the [Library] for the given [mirror] if it has already been
   /// created, else creates it.
   factory Library(LibraryMirror mirror) {
     var library = getDocgenObject(mirror);
     if (library is DummyMirror) {
       library = new Library._(mirror);
     }
     return library;
   }
 
   Library._(LibraryMirror libraryMirror) : super(libraryMirror) {
-    var exported = _calcExportedItems(libraryMirror);
-    var exportedClasses = _addAll(exported['classes'],
+    var exported = calcExportedItems(libraryMirror);
+    var exportedClasses = addAll(exported['classes'],
         dart2js_util.typesOf(libraryMirror.declarations));
     updateLibraryPackage(mirror);
     exportedClasses.forEach((String mirrorName, TypeMirror mirror) {
         if (mirror is TypedefMirror) {
           // This is actually a Dart2jsTypedefMirror, and it does define value,
           // but we don't have visibility to that type.
           if (includePrivateMembers || !mirror.isPrivate) {
             typedefs[dart2js_util.nameOf(mirror)] = new Typedef(mirror, this);
           }
         } else if (mirror is ClassMirror) {
           var clazz = new Class(mirror, this);
 
           if (clazz.isError()) {
             errors[dart2js_util.nameOf(mirror)] = clazz;
           } else {
             classes[dart2js_util.nameOf(mirror)] = clazz;
           }
         } else {
           throw new ArgumentError(
               '${dart2js_util.nameOf(mirror)} - no class type match. ');
         }
     });
-    this.functions = _createMethods(_addAll(exported['methods'],
+    this.functions = createMethods(addAll(exported['methods'],
         libraryMirror.declarations.values.where(
             (mirror) => mirror is MethodMirror)).values, this);
-    this.variables = _createVariables(_addAll(exported['variables'],
+    this.variables = createVariables(addAll(exported['variables'],
         dart2js_util.variablesOf(libraryMirror.declarations)).values, this);
   }
 
   /// Look for the specified name starting with the current member, and
   /// progressively working outward to the current library scope.
   String findElementInScope(String name) {
     var lookupFunc = determineLookupFunc(name);
     var libraryScope = lookupFunc(mirror, name);
     if (libraryScope != null) {
       var result = getDocgenObject(libraryScope, this);
       if (result is DummyMirror) return packagePrefix + result.docName;
       return result.packagePrefix + result.docName;
     }
     return super.findElementInScope(name);
   }
 
   String _mdnComment() => '';
 
-  /// Helper that maps [mirrors] to their simple name in map.
-  static Map _addAll(Map map, Iterable<DeclarationMirror> mirrors) {
-    for (var mirror in mirrors) {
-      map[dart2js_util.nameOf(mirror)] = mirror;
-    }
-    return map;
-  }
-
   /// For a library's [mirror], determine the name of the package (if any) we
   /// believe it came from (because of its file URI).
   ///
   /// If no package could be determined, we return an empty string.
   void updateLibraryPackage(LibraryMirror mirror) {
     if (mirror == null) return;
     if (_hasBeenCheckedForPackage) return;
     _hasBeenCheckedForPackage = true;
     if (mirror.uri.scheme != 'file') return;
     packageName = getPackageName(mirror);
@@ skipping 32 matching lines @@
     }
     return basic;
   }
 
   String get name => docName;
 
   String get docName {
     return dart2js_util.qualifiedNameOf(mirror).replaceAll('.','-');
   }
 
-  /// For the given library determine what items (if any) are exported.
-  ///
-  /// Returns a Map with three keys: "classes", "methods", and "variables" the
-  /// values of which point to a map of exported name identifiers with values
-  /// corresponding to the actual DeclarationMirror.
-  Map<String, Map<String, DeclarationMirror>> _calcExportedItems(
-      LibrarySourceMirror library) {
-    var exports = {};
-    exports['classes'] = {};
-    exports['methods'] = {};
-    exports['variables'] = {};
-
-    // Determine the classes, variables and methods that are exported for a
-    // specific dependency.
-    void _populateExports(LibraryDependencyMirror export, bool showExport) {
-      if (!showExport) {
-        // Add all items, and then remove the hidden ones.
-        // Ex: "export foo hide bar"
-        _addAll(exports['classes'],
-            dart2js_util.typesOf(export.targetLibrary.declarations));
-        _addAll(exports['methods'],
-            export.targetLibrary.declarations.values.where(
-                (mirror) => mirror is MethodMirror));
-        _addAll(exports['variables'],
-            dart2js_util.variablesOf(export.targetLibrary.declarations));
-      }
-      for (CombinatorMirror combinator in export.combinators) {
-        for (String identifier in combinator.identifiers) {
-          var librarySourceMirror =
-              export.targetLibrary as DeclarationSourceMirror;
-          var declaration = librarySourceMirror.lookupInScope(identifier);
-          if (declaration == null) {
-            // Technically this should be a bug, but some of our packages
-            // (such as the polymer package) are curently broken in this
-            // way, so we just produce a warning.
-            print('Warning identifier $identifier not found in library '
-                '${dart2js_util.qualifiedNameOf(export.targetLibrary)}');
-          } else {
-            var subMap = exports['classes'];
-            if (declaration is MethodMirror) {
-              subMap = exports['methods'];
-            } else if (declaration is VariableMirror) {
-              subMap = exports['variables'];
-            }
-            if (showExport) {
-              subMap[identifier] = declaration;
-            } else {
-              subMap.remove(identifier);
-            }
-          }
-        }
-      }
-    }
-
-    Iterable<LibraryDependencyMirror> exportList =
-        library.libraryDependencies.where((lib) => lib.isExport);
-    for (LibraryDependencyMirror export in exportList) {
-      // If there is a show in the export, add only the show items to the
-      // library. Ex: "export foo show bar"
-      // Otherwise, add all items, and then remove the hidden ones.
-      // Ex: "export foo hide bar"
-      _populateExports(export,
-          export.combinators.any((combinator) => combinator.isShow));
-    }
-    return exports;
-  }
-
   /// Checks if the given name is a key for any of the Class Maps.
   bool containsKey(String name) =>
       classes.containsKey(name) || errors.containsKey(name);
 
   /// Generates a map describing the [Library] object.
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
     'variables': recurseMap(variables),
     'functions': _expandMethodMap(functions),
     'classes': {
       'class': classes.values.where((c) => c.isVisible)
         .map((e) => e.previewMap).toList(),
       'typedef': recurseMap(typedefs),
       'error': errors.values.where((e) => e.isVisible)
           .map((e) => e.previewMap).toList()
     },
     'packageName': packageName,
     'packageIntro' : packageIntro
   };
 
   String get typeName => 'library';
 
   bool isValidMirror(DeclarationMirror mirror) => mirror is LibraryMirror;
 }
 
-abstract class OwnedIndexable extends Indexable {
+abstract class OwnedIndexable<TMirror extends DeclarationMirror>
+    extends Indexable<TMirror> {
+  /// List of the meta annotations on this item.
+  final List<Annotation> annotations;
+
   /// The object one scope-level above which this item is defined.
   ///
   /// Ex: The owner for a top level class, would be its enclosing library.
   /// The owner of a local variable in a method would be the enclosing method.
-  Indexable owner;
-
-  /// List of the meta annotations on this item.
-  List<Annotation> annotations;
+  final Indexable owner;
 
   /// Returns this object's qualified name, but following the conventions
   /// we're using in Dartdoc, which is that library names with dots in them
   /// have them replaced with hyphens.
   String get docName => owner.docName + '.' + dart2js_util.nameOf(mirror);
 
-  OwnedIndexable(DeclarationMirror mirror, this.owner) : super(mirror);
+  OwnedIndexable(DeclarationMirror mirror, Indexable owner)
+      : annotations = createAnnotations(mirror, owner.owningLibrary),
+        this.owner = owner,
+        super(mirror);
 
   /// Generates MDN comments from database.json.
   String _mdnComment() {
     var domAnnotation = this.annotations.firstWhere(
         (e) => e.mirror.qualifiedName == #metadata.DomName,
         orElse: () => null);
     if (domAnnotation == null) return '';
     var domName = domAnnotation.parameters.single;
 
     return mdnComment(rootDirectory, logger, domName);
   }
 
   String get packagePrefix => owner.packagePrefix;
 }
 
 /// A class containing contents of a Dart class.
-class Class extends OwnedIndexable implements Comparable {
+class Class
+    extends OwnedIndexable<dart2js_mirrors.Dart2JsInterfaceTypeMirror>
+    implements Comparable<Class> {
 
   /// List of the names of interfaces that this class implements.
   List<Class> interfaces = [];
 
   /// Names of classes that extends or implements this class.
   Set<Class> subclasses = new Set<Class>();
 
   /// Top-level variables in the class.
   Map<String, Variable> variables;
 
   /// Inherited variables in the class.
-  Map<String, Variable> inheritedVariables;
+  final Map<String, Variable> inheritedVariables = {};
 
   /// Methods in the class.
   Map<String, Method> methods;
 
-  Map<String, Method> inheritedMethods;
+  final Map<String, Method> inheritedMethods = new Map<String, Method>();
 
   /// Generic infomation about the class.
-  Map<String, Generic> generics;
+  final Map<String, Generic> generics;
 
   Class superclass;
-  bool isAbstract;
+  bool get isAbstract => mirror.isAbstract;
 
   /// Make sure that we don't check for inherited comments more than once.
   bool _commentsEnsured = false;
 
   /// Returns the [Class] for the given [mirror] if it has already been created,
   /// else creates it.
   factory Class(ClassMirror mirror, Library owner) {
     var clazz = getDocgenObject(mirror, owner);
     if (clazz is DummyMirror) {
       clazz = new Class._(mirror, owner);
@@ skipping 12 matching lines @@
       if (realOwner is Library) {
         return new Class(mirror, realOwner);
       } else {
         return new Class(mirror, originalOwner);
       }
     } else {
       return new Class(mirror, originalOwner);
     }
   }
 
-  Class._(ClassSourceMirror classMirror, Indexable owner) :
-      super(classMirror, owner) {
-    inheritedVariables = {};
+  Class._(ClassSourceMirror classMirror, Indexable owner)
+      : generics = createGenerics(classMirror),
+        super(classMirror, owner) {
 
     // The reason we do this madness is the superclass and interface owners may
     // not be this class's owner!! Example: BaseClient in http pkg.
     var superinterfaces = classMirror.superinterfaces.map(
         (interface) => new Class._possiblyDifferentOwner(interface, owner));
     this.superclass = classMirror.superclass == null? null :
         new Class._possiblyDifferentOwner(classMirror.superclass, owner);
 
     interfaces = superinterfaces.toList();
-    variables = _createVariables(
+    variables = createVariables(
         dart2js_util.variablesOf(classMirror.declarations), this);
-    methods = _createMethods(classMirror.declarations.values.where(
+    methods = createMethods(classMirror.declarations.values.where(
         (mirror) => mirror is MethodMirror), this);
-    annotations = createAnnotations(classMirror, owner._owningLibrary);
-    generics = _createGenerics(classMirror);
-    isAbstract = classMirror.isAbstract;
-    inheritedMethods = new Map<String, Method>();
 
     // Tell superclass that you are a subclass, unless you are not
     // visible or an intermediary mixin class.
     if (!classMirror.isNameSynthetic && isVisible && superclass != null) {
       superclass.addSubclass(this);
     }
 
     if (this.superclass != null) addInherited(superclass);
     interfaces.forEach((interface) => addInherited(interface));
   }
@@ skipping 131 matching lines @@
     'subclass': (subclasses.toList()..sort())
         .map((x) => x.qualifiedName).toList(),
     'variables': recurseMap(variables),
     'inheritedVariables': recurseMap(inheritedVariables),
     'methods': _expandMethodMap(methods),
     'inheritedMethods': _expandMethodMap(inheritedMethods),
     'annotations': annotations.map((a) => a.toMap()).toList(),
     'generics': recurseMap(generics)
   };
 
-  int compareTo(aClass) => name.compareTo(aClass.name);
+  int compareTo(Class other) => name.compareTo(other.name);
 
   bool isValidMirror(DeclarationMirror mirror) => mirror is ClassMirror;
 }
 
 class Typedef extends OwnedIndexable {
-  String returnType;
+  final String returnType;
 
-  Map<String, Parameter> parameters;
+  final Map<String, Parameter> parameters;
 
   /// Generic information about the typedef.
-  Map<String, Generic> generics;
+  final Map<String, Generic> generics;
 
   /// Returns the [Library] for the given [mirror] if it has already been
   /// created, else creates it.
   factory Typedef(TypedefMirror mirror, Library owningLibrary) {
     var aTypedef = getDocgenObject(mirror, owningLibrary);
     if (aTypedef is DummyMirror) {
       aTypedef = new Typedef._(mirror, owningLibrary);
     }
     return aTypedef;
   }
 
-  Typedef._(TypedefMirror mirror, Library owningLibrary) :
-      super(mirror, owningLibrary) {
-    returnType = getDocgenObject(mirror.referent.returnType).docName;
-    generics = _createGenerics(mirror);
-    parameters = _createParameters(mirror.referent.parameters, owningLibrary);
-    annotations = createAnnotations(mirror, owningLibrary);
-  }
+  Typedef._(TypedefMirror mirror, Library owningLibrary)
+      : returnType = getDocgenObject(mirror.referent.returnType).docName,
+        generics = createGenerics(mirror),
+        parameters = createParameters(mirror.referent.parameters,
+            owningLibrary),
+        super(mirror, owningLibrary);
 
   Map toMap() {
     var map = {
       'name': name,
       'qualifiedName': qualifiedName,
       'comment': comment,
       'return': returnType,
       'parameters': recurseMap(parameters),
       'annotations': annotations.map((a) => a.toMap()).toList(),
       'generics': recurseMap(generics)
@@ skipping 30 matching lines @@
       return new Variable._(variableName, mirror, owner);
     }
     return variable;
   }
 
   Variable._(this._variableName, VariableMirror mirror, Indexable owner) :
       super(mirror, owner) {
     isFinal = mirror.isFinal;
     isStatic = mirror.isStatic;
     isConst = mirror.isConst;
-    type = new Type(mirror.type, owner._owningLibrary);
-    annotations = createAnnotations(mirror, owner._owningLibrary);
+    type = new Type(mirror.type, owner.owningLibrary);
   }
 
   String get name => _variableName;
 
   /// Generates a map describing the [Variable] object.
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
     'final': isFinal,
@@ skipping 31 matching lines @@
     return super.findElementInScope(name);
   }
 
   bool isValidMirror(DeclarationMirror mirror) => mirror is VariableMirror;
 }
 
 /// A class containing properties of a Dart method.
 class Method extends OwnedIndexable {
 
   /// Parameters for this method.
-  Map<String, Parameter> parameters;
+  final Map<String, Parameter> parameters;
 
-  bool isStatic;
-  bool isAbstract;
-  bool isConst;
-  Type returnType;
+  final bool isStatic;
+  final bool isAbstract;
+  final bool isConst;
+  final Type returnType;
   Method methodInheritedFrom;
 
   /// Qualified name to state where the comment is inherited from.
   String commentInheritedFrom = "";
 
   factory Method(MethodMirror mirror, Indexable owner,
       [Method methodInheritedFrom]) {
     var method = getDocgenObject(mirror, owner);
     if (method is DummyMirror) {
       method = new Method._(mirror, owner, methodInheritedFrom);
     }
     return method;
   }
 
   Method._(MethodMirror mirror, Indexable owner, this.methodInheritedFrom)
-      : super(mirror, owner) {
-    isStatic = mirror.isStatic;
-    isAbstract = mirror.isAbstract;
-    isConst = mirror.isConstConstructor;
-    returnType = new Type(mirror.returnType, owner._owningLibrary);
-    parameters = _createParameters(mirror.parameters, owner);
-    annotations = createAnnotations(mirror, owner._owningLibrary);
-  }
+      : returnType = new Type(mirror.returnType, owner.owningLibrary),
+        isStatic = mirror.isStatic,
+        isAbstract = mirror.isAbstract,
+        isConst = mirror.isConstConstructor,
+        parameters = createParameters(mirror.parameters, owner),
+        super(mirror, owner);
 
   Method get originallyInheritedFrom => methodInheritedFrom == null ?
       this : methodInheritedFrom.originallyInheritedFrom;
 
   /// Look for the specified name starting with the current member, and
   /// progressively working outward to the current library scope.
   String findElementInScope(String name) {
     var lookupFunc = determineLookupFunc(name);
 
     var memberScope = lookupFunc(this.mirror, name);
@@ skipping 47 matching lines @@
     'qualifiedName': qualifiedName,
     'comment': comment,
     'commentFrom': (methodInheritedFrom != null &&
         commentInheritedFrom == methodInheritedFrom.docName ? ''
         : commentInheritedFrom),
     'inheritedFrom': (methodInheritedFrom == null? '' :
         originallyInheritedFrom.docName),
     'static': isStatic,
     'abstract': isAbstract,
     'constant': isConst,
-    'return': new List.filled(1, returnType.toMap()),
+    'return': [returnType.toMap()],
     'parameters': recurseMap(parameters),
     'annotations': annotations.map((a) => a.toMap()).toList()
   };
 
   String get typeName {
     MethodMirror theMirror = mirror;
     if (theMirror.isConstructor) return 'constructor';
     if (theMirror.isGetter) return 'getter';
     if (theMirror.isSetter) return'setter';
     if (theMirror.isOperator) return 'operator';
@@ skipping 88 matching lines @@
 ///                - "outer" : "dart-core.List"
 ///                  "inner" :
 ///                    - "outer" : "dart-core.int"
 ///                      "inner" :
 class Type extends MirrorBased {
   final TypeMirror mirror;
   final Library owningLibrary;
 
   Type(this.mirror, this.owningLibrary);
 
-  /// Returns a list of [Type] objects constructed from TypeMirrors.
-  List<Type> _createTypeGenerics(TypeMirror mirror) {
-    if (mirror is ClassMirror) {
-      var innerList = [];
-      mirror.typeArguments.forEach((e) {
-        innerList.add(new Type(e, owningLibrary));
-      });
-      return innerList;
-    }
-    return [];
-  }
-
   Map toMap() {
     var result = getDocgenObject(mirror, owningLibrary);
     return {
       // We may encounter types whose corresponding library has not been
       // processed yet, so look up with the owningLibrary at the last moment.
       'outer': result.packagePrefix + result.docName,
       'inner': _createTypeGenerics(mirror).map((e) => e.toMap()).toList(),
     };
   }
+
+  /// Returns a list of [Type] objects constructed from TypeMirrors.
+  List<Type> _createTypeGenerics(TypeMirror mirror) {
+    if (mirror is! ClassMirror) return [];
+    return mirror.typeArguments.map((e) => new Type(e, owningLibrary)).toList();
+  }
 }
 
 /// Holds the name of the annotation, and its parameters.
 class Annotation extends MirrorBased {
   /// The class of this annotation.
   final ClassMirror mirror;
   final Library owningLibrary;
   List<String> parameters;
 
   Annotation(InstanceMirror originalMirror, this.owningLibrary)
       : mirror = originalMirror.type {
     parameters = dart2js_util.variablesOf(originalMirror.type.declarations)
         .where((e) => e.isFinal)
         .map((e) => originalMirror.getField(e.simpleName).reflectee)
         .where((e) => e != null)
         .toList();
   }
 
   Map toMap() => {
     'name': getDocgenObject(mirror, owningLibrary).docName,
     'parameters': parameters
   };
 }