annotation with parameters.

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.
  *
@@ skipping 251 matching lines @@
 bool _isLibraryPrivate(LibraryMirror mirror) {
   if (mirror.simpleName.startsWith('_') || mirror.simpleName.contains('._')) {
     return true;
   }
   return false;
 }
 
 /**
  * A declaration is private if itself is private, or the owner is private. 
  */
+// Issue(12202) - A declaration is public even if it's owner is private. 
 bool _isPrivate(DeclarationMirror mirror) {

[Bob Nystrom, 2013/08/02 15:36:04]

I worry about using "private" here because this definition is a bit different
from what the language considers "private" to mean. Would _isVisible/_isHidden
work here?

[janicejl, 2013/08/02 22:08:07]

Done.

   if (mirror is LibraryMirror) {
     return _isLibraryPrivate(mirror);
   } else if (mirror.owner is LibraryMirror) {
     return (mirror.isPrivate || _isLibraryPrivate(mirror.owner));
   } else { 
     return (mirror.isPrivate || _isPrivate(mirror.owner));
   }
 }
 
 bool _filterPrivate(Indexable item) {
   return _includePrivate || !item.isPrivate;
 }
 
 /**
  * Returns a list of meta annotations assocated with a mirror.
  */
 List<String> _annotations(DeclarationMirror mirror) {
-  var annotations = mirror.metadata.where((e) =>
+  var annotationMirrors = mirror.metadata.where((e) =>
       e is dart2js.Dart2JsConstructedConstantMirror);
-  return annotations.map((e) => e.type.qualifiedName).toList();
+  var annotations = [];
+  annotationMirrors.forEach((annotation) {
+    var parameterList = [];
+    annotation.type.variables.values.where((e) => e.isFinal).forEach ((v) {
+      parameterList.add(annotation.getField(v.simpleName).reflectee);
+    });

[Bob Nystrom, 2013/08/02 15:36:04]

When you iterate over a sequence and call .add() on a list inside it, that's
often a hint that map() can be used. Try:

var parameterList = annotation.type.variables.values
    .where((e) => e.isFinal)
    .map((e) => e.getField(v.simpleName).reflectee)
    .toList();

[janicejl, 2013/08/02 22:08:07]

Done.

+    annotations.add(new Annotation(annotation.type.qualifiedName,
+        parameterList));
+  });
+  return annotations;
 }
 
 /**
  * Returns any documentation comments associated with a mirror with
  * simple markdown converted to html.
  */
 String _commentToHtml(DeclarationMirror mirror) {
   String commentText;
   mirror.metadata.forEach((metadata) {
     if (metadata is CommentInstanceMirror) {
@@ skipping 413 matching lines @@
       this.parameters, this.annotations,
       String qualifiedName, bool isPrivate, String owner) : super(name, comment,
           qualifiedName, isPrivate, owner) {}
   
   Map toMap() => {
     'name': name,
     'qualifiedname': qualifiedName,
     'comment': comment,
     'return': returnType,
     'parameters': recurseMap(parameters),
-    'annotations': new List.from(annotations),
+    'annotations': new List.from(annotations.map((a) => a.toMap())),

[Bob Nystrom, 2013/08/02 15:36:04]

Instead of new List.from(), use toList():

annotations.map((a) => a.toMap()).toList()

Below too.

[janicejl, 2013/08/02 22:08:07]

Done.

     'generics': recurseMap(generics)
   };
 }
 
 /**
  * A class containing properties of a Dart variable.
  */
 class Variable extends Indexable {
 
   bool isFinal;
@@ skipping 10 matching lines @@
   
   /// Generates a map describing the [Variable] object.
   Map toMap() => {
     'name': name,
     'qualifiedname': qualifiedName,
     'comment': comment,
     'final': isFinal.toString(),
     'static': isStatic.toString(),
     'constant': isConst.toString(),
     'type': new List.filled(1, type.toMap()),
-    'annotations': new List.from(annotations)
+    'annotations': new List.from(annotations.map((a) => a.toMap()))
   };
 }
 
 /**
  * A class containing properties of a Dart method.
  */
 class Method extends Indexable {
 
   /// Parameters for this method.
   Map<String, Parameter> parameters;
@@ skipping 14 matching lines @@
   /// Generates a map describing the [Method] object.
   Map toMap() => {
     'name': name,
     'qualifiedname': qualifiedName,
     'comment': comment,
     'static': isStatic.toString(),
     'abstract': isAbstract.toString(),
     'constant': isConst.toString(),
     'return': new List.filled(1, returnType.toMap()),
     'parameters': recurseMap(parameters),
-    'annotations': new List.from(annotations)
+    'annotations': new List.from(annotations.map((a) => a.toMap()))
   };
 }
 
 /**
  * A container to categorize methods into the following groups: setters, 
  * getters, constructors, operators, regular methods. 
  */
 class MethodGroup {
   Map<String, Method> setters = {};
   Map<String, Method> getters = {};
@@ skipping 65 matching lines @@
       this.type, this.defaultValue, this.annotations);
   
   /// Generates a map describing the [Parameter] object.
   Map toMap() => {
     'name': name,
     'optional': isOptional.toString(),
     'named': isNamed.toString(),
     'default': hasDefaultValue.toString(),
     'type': new List.filled(1, type.toMap()),
     'value': defaultValue,
-    'annotations': new List.from(annotations)
+    'annotations': new List.from(annotations.map((a) => a.toMap()))
   };
 }
 
 /**
  * A class containing properties of a Generic. 
  */
 class Generic {
   String name;
   String type;
   
@@ skipping 38 matching lines @@
 class Type {
   String outer;
   List<Type> inner;
   
   Type(this.outer, this.inner);
   
   Map toMap() => {
     'outer': outer,
     'inner': new List.from(inner.map((e) => e.toMap()))
   };
+}
+
+/**
+ * Holds the name of the annotation, and its parameters. 
+ */
+class Annotation {
+  String qualifiedName;
+  List<String> parameters; 
+  
+  Annotation(this.qualifiedName, this.parameters);
+  
+  Map toMap() => {
+    'name': qualifiedName,
+    'metaparameters': new List.from(parameters)

[Bob Nystrom, 2013/08/02 15:36:04]

Why "metaparameters" and not just "parameters"?

Is the new List.from() needed here? If so, why?

[janicejl, 2013/08/02 22:08:07]

Done.

+  };
 }