pkg/docgen: fixed type references within typedef doc comments

pkg/docgen/lib/src/models/method.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.method;
 
 import 'package:markdown/markdown.dart' as markdown;
 
 import '../exports/mirrors_util.dart' as dart2js_util;
 import '../exports/source_mirrors.dart';
 
 import '../library_helpers.dart';
 
 import 'class.dart';
 import 'doc_gen_type.dart';
 import 'dummy_mirror.dart';
 import 'indexable.dart';
 import 'model_helpers.dart';
 import 'owned_indexable.dart';
 import 'parameter.dart';
 
 
 /// A class containing properties of a Dart method.
-class Method extends OwnedIndexable {
+class Method extends OwnedIndexable<MethodMirror> {
 
   /// Parameters for this method.
   final Map<String, Parameter> parameters;
 
   final bool isStatic;
   final bool isAbstract;
   final bool isConst;
   final DocGenType returnType;
   Method methodInheritedFrom;
 
@@ skipping 41 matching lines @@
     }
 
     if (owner != null) {
       var result = owner.findElementInScope(name);
       if (result != null) return result;
     }
     return super.findElementInScope(name);
   }
 
   String get docName {
-    if ((mirror as MethodMirror).isConstructor) {
+    if (mirror.isConstructor) {

[kevmoo, 2014/04/20 21:34:54]

Benefit of defining the generic type of 'mirror'

       // We name constructors specially -- including the class name again and a
       // "-" to separate the constructor from its name (if any).
       return '${owner.docName}.${dart2js_util.nameOf(mirror.owner)}-'
           '${dart2js_util.nameOf(mirror)}';
     }
     return super.docName;
   }
 
   String get fileName => packagePrefix + docName;
 
@@ skipping 20 matching lines @@
         originallyInheritedFrom.docName),
     'static': isStatic,
     'abstract': isAbstract,
     'constant': isConst,
     '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';
+    if (mirror.isConstructor) return 'constructor';

[kevmoo, 2014/04/20 21:34:54]

Benefit of defining the generic type of 'mirror'

+    if (mirror.isGetter) return 'getter';
+    if (mirror.isSetter) return 'setter';
+    if (mirror.isOperator) return 'operator';
     return 'method';
   }
 
   String get comment {
     if (commentField != null) return commentField;
     if (owner is Class) {
       (owner as Class).ensureComments();
     }
     var result = super.comment;
     if (result == '' && methodInheritedFrom != null) {
       // This should be NOT from the MIRROR, but from the COMMENT.
       methodInheritedFrom.comment; // Ensure comment field has been populated.
       unresolvedComment = methodInheritedFrom.unresolvedComment;
 
       comment = unresolvedComment == null ? '' :
         markdown.markdownToHtml(unresolvedComment.trim(),
             linkResolver: fixReference, inlineSyntaxes: MARKDOWN_SYNTAXES);
       commentInheritedFrom = comment != '' ?
           methodInheritedFrom.commentInheritedFrom : '';
       result = comment;
     }
     return result;
   }
 
   bool isValidMirror(DeclarationMirror mirror) => mirror is MethodMirror;
 }