pkg/docgen: updated min dependencies of args and unittest

pkg/docgen/lib/docgen.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.
 
 /// **docgen** is a tool for creating machine readable representations of Dart
 /// code metadata, including: classes, members, comments and annotations.
 ///
 /// docgen is run on a `.dart` file or a directory containing `.dart` files.
 ///
 ///      $ dart docgen.dart [OPTIONS] [FILE/DIR]
@@ skipping 206 matching lines @@
   }
 }
 
 /// Docgen representation of an item to be documented, that wraps around a
 /// dart2js mirror.
 abstract class MirrorBased {
   /// The original dart2js mirror around which this object wraps.
   DeclarationMirror get mirror;
 
   /// Returns a list of meta annotations assocated with a mirror.
-  List<Annotation> _createAnnotations(DeclarationMirror mirror,
+  static List<Annotation> _createAnnotations(DeclarationMirror mirror,
       Library owningLibrary) {
     var annotationMirrors = mirror.metadata.where((e) =>
         e is dart2js_mirrors.Dart2JsConstructedConstantMirror);
     var annotations = [];
     annotationMirrors.forEach((annotation) {
       var docgenAnnotation = new Annotation(annotation, owningLibrary);
       if (!_SKIPPED_ANNOTATIONS.contains(
           dart2js_util.qualifiedNameOf(docgenAnnotation.mirror))) {
         annotations.add(docgenAnnotation);
       }
@@ skipping 1424 matching lines @@
     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(
         dart2js_util.variablesOf(classMirror.declarations), this);
     methods = _createMethods(classMirror.declarations.values.where(
         (mirror) => mirror is MethodMirror), this);
-    annotations = _createAnnotations(classMirror, _getOwningLibrary(owner));
+    annotations = MirrorBased._createAnnotations(classMirror, _getOwningLibrary(owner));
     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);
     }
 
@@ skipping 162 matching lines @@
       aTypedef = new Typedef._(mirror, owningLibrary);
     }
     return aTypedef;
   }
 
   Typedef._(TypedefMirror mirror, Library owningLibrary) :
       super(mirror, owningLibrary) {
     returnType = Indexable.getDocgenObject(mirror.referent.returnType).docName;
     generics = _createGenerics(mirror);
     parameters = _createParameters(mirror.referent.parameters, owningLibrary);
-    annotations = _createAnnotations(mirror, owningLibrary);
+    annotations = MirrorBased._createAnnotations(mirror, owningLibrary);
   }
 
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
     'return': returnType,
     'parameters': recurseMap(parameters),
     'annotations': annotations.map((a) => a.toMap()).toList(),
     'generics': recurseMap(generics)
@@ skipping 23 matching lines @@
     }
     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, _getOwningLibrary(owner));
-    annotations = _createAnnotations(mirror, _getOwningLibrary(owner));
+    annotations = MirrorBased._createAnnotations(mirror, _getOwningLibrary(owner));
   }
 
   String get name => _variableName;
 
   /// Generates a map describing the [Variable] object.
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
-    'final': isFinal.toString(),

[Alan Knight, 2014/02/19 19:00:46]

Have we tested how the viewer deals with this?

-    'static': isStatic.toString(),
-    'constant': isConst.toString(),
+    'final': isFinal,
+    'static': isStatic,
+    'constant': isConst,
     'type': new List.filled(1, type.toMap()),
     'annotations': annotations.map((a) => a.toMap()).toList()
   };
 
   String get typeName => 'property';
 
   get comment {
     if (_comment != null) return _comment;
     if (owner is Class) {
       (owner as Class).ensureComments();
@@ skipping 46 matching lines @@
     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, _getOwningLibrary(owner));
     parameters = _createParameters(mirror.parameters, owner);
-    annotations = _createAnnotations(mirror, _getOwningLibrary(owner));
+    annotations = MirrorBased._createAnnotations(mirror, _getOwningLibrary(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 = Indexable.determineLookupFunc(name);
 
@@ skipping 45 matching lines @@
   /// Generates a map describing the [Method] object.
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
     'commentFrom': (methodInheritedFrom != null &&
         commentInheritedFrom == methodInheritedFrom.docName ? ''
         : commentInheritedFrom),
     'inheritedFrom': (methodInheritedFrom == null? '' :
         originallyInheritedFrom.docName),
-    'static': isStatic.toString(),
-    'abstract': isAbstract.toString(),
-    'constant': isConst.toString(),
+    'static': isStatic,
+    'abstract': isAbstract,
+    'constant': isConst,
     'return': new List.filled(1, 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';
@@ skipping 22 matching lines @@
     }
     return result;
   }
 
   bool _isValidMirror(DeclarationMirror mirror) => mirror is MethodMirror;
 }
 
 /// Docgen wrapper around the dart2js mirror for a Dart
 /// method/function parameter.
 class Parameter extends MirrorBased {
-  ParameterMirror mirror;
-  String name;
-  bool isOptional;
-  bool isNamed;
-  bool hasDefaultValue;
-  Type type;
-  String defaultValue;
+  final ParameterMirror mirror;
+  final String name;
+  final bool isOptional;
+  final bool isNamed;
+  final bool hasDefaultValue;
+  final Type type;
+  final String defaultValue;
   /// List of the meta annotations on the parameter.
-  List<Annotation> annotations;
+  final List<Annotation> annotations;
 
-  Parameter(this.mirror, Library owningLibrary) {
-    name = dart2js_util.nameOf(mirror);
-    isOptional = mirror.isOptional;
-    isNamed = mirror.isNamed;
-    hasDefaultValue = mirror.hasDefaultValue;
-    defaultValue = '${mirror.defaultValue}';
-    type = new Type(mirror.type, owningLibrary);
-    annotations = _createAnnotations(mirror, owningLibrary);
-  }
+  Parameter(ParameterMirror mirror, Library owningLibrary)

[Emily Fortuna, 2014/02/19 17:11:21]

is this change really worth it? 

[kevmoo, 2014/02/19 17:13:23]

It's tough for me to read through a class that could be in finals without moving
it to finals.

+      : this.mirror = mirror,
+        name = dart2js_util.nameOf(mirror),
+        isOptional = mirror.isOptional,
+        isNamed = mirror.isNamed,
+        hasDefaultValue = mirror.hasDefaultValue,
+        defaultValue = '${mirror.defaultValue}',
+        type = new Type(mirror.type, owningLibrary),

[Emily Fortuna, 2014/02/19 17:11:21]

can this be done here?

[kevmoo, 2014/02/19 17:13:23]

Can what be done where? :-)

+        annotations = MirrorBased._createAnnotations(mirror, owningLibrary);
 
   /// Generates a map describing the [Parameter] object.
   Map toMap() => {
     'name': name,
-    'optional': isOptional.toString(),
-    'named': isNamed.toString(),
-    'default': hasDefaultValue.toString(),
+    'optional': isOptional,
+    'named': isNamed,
+    'default': hasDefaultValue,
     'type': new List.filled(1, type.toMap()),
     'value': defaultValue,
     'annotations': annotations.map((a) => a.toMap()).toList()
   };
 }
 
 /// A Docgen wrapper around the dart2js mirror for a generic type.
 class Generic extends MirrorBased {
-  TypeVariableMirror mirror;
+  final TypeVariableMirror mirror;
   Generic(this.mirror);
   Map toMap() => {
     'name': dart2js_util.nameOf(mirror),
     'type': dart2js_util.qualifiedNameOf(mirror.upperBound)
   };
 }
 
 /// Docgen wrapper around the mirror for a return type, and/or its generic
 /// type parameters.
 ///
@@ skipping 17 matching lines @@
 ///          "return" :
 ///            - "outer" : "dart-core.Map"
 ///              "inner" :
 ///                - "outer" : "dart-core.String"
 ///                  "inner" :
 ///                - "outer" : "dart-core.List"
 ///                  "inner" :
 ///                    - "outer" : "dart-core.int"
 ///                      "inner" :
 class Type extends MirrorBased {
-  TypeMirror mirror;
-  Library owningLibrary;
+  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 = Indexable.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(),
     };
   }
 }
 
 /// 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;
-  /// The class of this annotation.
-  ClassMirror mirror;
-  Library owningLibrary;
 
-  Annotation(InstanceMirror originalMirror, this.owningLibrary) {
-    mirror = originalMirror.type;
+  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': Indexable.getDocgenObject(mirror, owningLibrary).docName,
     'parameters': parameters
   };
 }