Make Mirror.simpleName unique.

pkg/dartdoc/lib/dartdoc.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.
 
 /**
  * To generate docs for a library, run this script with the path to an
  * entrypoint .dart file, like:
  *
  *     $ dart dartdoc.dart foo.dart
  *
@@ skipping 557 matching lines @@
     final List members = docMembersJson(library.declaredMembers);
     if (!members.isEmpty()) {
       libraryInfo[MEMBERS] = members;
     }
 
     final types = [];
     for (InterfaceMirror type in orderByName(library.types.getValues())) {
       if (type.isPrivate) continue;
 
       var typeInfo = {};
-      typeInfo[NAME] = type.simpleName;
+      typeInfo[NAME] = type.displayName;
       if (type.isClass) {
         typeInfo[KIND] = CLASS;
       } else if (type.isInterface) {
         typeInfo[KIND] = INTERFACE;
       } else {
         assert(type.isTypedef);
         typeInfo[KIND] = TYPEDEF;
       }
       final List typeMembers = docMembersJson(type.declaredMembers);
       if (!typeMembers.isEmpty()) {
         typeInfo[MEMBERS] = typeMembers;
       }
 
       if (!type.declaration.typeVariables.isEmpty()) {
         final typeVariables = [];
         for (final typeVariable in type.declaration.typeVariables) {
-          typeVariables.add(typeVariable.simpleName);
+          typeVariables.add(typeVariable.displayName);
         }
         typeInfo[ARGS] = Strings.join(typeVariables, ', ');
       }
       types.add(typeInfo);
     }
     if (!types.isEmpty()) {
       libraryInfo[TYPES] = types;
     }
 
     libraryList.add(libraryInfo);
   }
 
   List docMembersJson(Map<Object,MemberMirror> memberMap) {
     final members = [];
     for (MemberMirror member in orderByName(memberMap.getValues())) {
       if (member.isPrivate) continue;
 
       var memberInfo = {};
       if (member.isField) {
-        memberInfo[NAME] = member.simpleName;
         memberInfo[KIND] = FIELD;
       } else {
         MethodMirror method = member;
         if (method.isConstructor) {
-          if (method.constructorName != '') {
-            memberInfo[NAME] = '${method.simpleName}.${method.constructorName}';
-            memberInfo[KIND] = CONSTRUCTOR;
-          } else {
-            memberInfo[NAME] = member.simpleName;
-            memberInfo[KIND] = CONSTRUCTOR;
-          }
-        } else if (method.isOperator) {
-          memberInfo[NAME] = '${method.simpleName} ${method.operatorName}';
-          memberInfo[KIND] = METHOD;
+          memberInfo[KIND] = CONSTRUCTOR;
         } else if (method.isSetter) {
-          memberInfo[NAME] = member.simpleName;
           memberInfo[KIND] = SETTER;
         } else if (method.isGetter) {
-          memberInfo[NAME] = member.simpleName;
           memberInfo[KIND] = GETTER;
         } else {
-          memberInfo[NAME] = member.simpleName;
           memberInfo[KIND] = METHOD;
         }
         if (method.parameters.isEmpty()) {
           memberInfo[NO_PARAMS] = true;
         }
       }
+      memberInfo[NAME] = member.displayName;
       var anchor = memberAnchor(member);
       if (anchor != memberInfo[NAME]) {
         memberInfo[LINK_NAME] = anchor;
       }
       members.add(memberInfo);
     }
     return members;
   }
 
   void docNavigation() {
@@ skipping 263 matching lines @@
           typeSpan(supertypes[i]);
           write('&nbsp;&gt;&nbsp;');
         }
 
         // Write this class.
         typeSpan(type);
         writeln('</p>');
       }
 
       listTypes(subtypes, 'Subclasses');
-      listTypes(type.interfaces.getValues(), 'Implements');
+      listTypes(type.interfaces, 'Implements');
     } else {
       // Show the default class.
       if (type.defaultType != null) {
         listTypes([type.defaultType], 'Default class');
       }
 
       // List extended interfaces.
-      listTypes(type.interfaces.getValues(), 'Extends');
+      listTypes(type.interfaces, 'Extends');
 
       // List subinterfaces and implementing classes.
       final subinterfaces = [];
       final implementing = [];
 
       for (final subtype in subtypes) {
         if (subtype.isClass) {
           implementing.add(subtype);
         } else {
           subinterfaces.add(subtype);
@@ skipping 120 matching lines @@
     if (method.isConstructor) {
       if (method.isFactory) {
         write('factory ');
       } else {
         write(method.isConst ? 'const ' : 'new ');
       }
     } else if (method.isAbstract) {
       write('abstract ');
     }
 
-    if (method.constructorName == null) {
+    if (!method.isConstructor) {
       annotateType(host, method.returnType);
     }
 
-    var name = method.simpleName;
+    var name = method.displayName;
     // Translate specially-named methods: getters, setters, operators.
     if (method.isGetter) {
       // Getter.
       name = 'get $name';
     } else if (method.isSetter) {
       // Setter.
       name = 'set $name';
-    } else if (method.isOperator) {
-      name = 'operator ${method.operatorName}';
     }
 
     write('<strong>$name</strong>');
 
-    // Named constructors.
-    if (method.constructorName != null && method.constructorName != '') {
-      write('.');
-      write(method.constructorName);
-    }
-
     docParamList(host, method.parameters);
 
     var prefix = host is LibraryMirror ? '' : '${typeName(host)}.';
     write(''' <a class="anchor-link" href="#${memberAnchor(method)}"
               title="Permalink to $prefix$name">#</a>''');
     writeln('</h4>');
 
     docCode(method.location, getMethodComment(method), showCode: showCode);
 
     writeln('</div>');
@@ skipping 152 matching lines @@
   }
 
   /** Gets the URL for the documentation for [member]. */
   String memberUrl(MemberMirror member) {
     String url = typeUrl(member.surroundingDeclaration);
     return '$url#${memberAnchor(member)}';
   }
 
   /** Gets the anchor id for the document for [member]. */
   String memberAnchor(MemberMirror member) {
-    if (member.isField) {
-      return member.simpleName;
-    }
-    MethodMirror method = member;
-    if (method.isConstructor) {
-      if (method.constructorName == '') {
-        return method.simpleName;
-      } else {
-        return '${method.simpleName}.${method.constructorName}';
-      }
-    } else if (method.isOperator) {
-      return '${method.simpleName} ${method.operatorName}';
-    } else if (method.isSetter) {
-      return '${method.simpleName}=';
-    } else {
-      return method.simpleName;
-    }
+    return member.simpleName;
   }
 
   /**
    * Creates a hyperlink. Handles turning the [href] into an appropriate
    * relative path from the current file.
    */
   String a(String href, String contents, [String css]) {
     // Mark outgoing external links, mainly so we can style them.
     final rel = isAbsolute(href) ? ' ref="external"' : '';
     final cssClass = css == null ? '' : ' class="$css"';
@@ skipping 173 matching lines @@
         if (parameter.simpleName == name) {
           final element = new md.Element.text('span', name);
           element.attributes['class'] = 'param';
           return element;
         }
       }
     }
 
     // See if it's another member of the current type.
     if (currentType != null) {
-      final foundMember = findMirror(currentType.declaredMembers, name);
+      final foundMember = currentType.declaredMembers[name];
       if (foundMember != null) {
         return makeLink(memberUrl(foundMember));
       }
     }
 
     // See if it's another type or a member of another type in the current
     // library.
     if (currentLibrary != null) {
       // See if it's a constructor
       final constructorLink = (() {
         final match =
             new RegExp(r'new ([\w$]+)(?:\.([\w$]+))?').firstMatch(name);
         if (match == null) return;
-        InterfaceMirror foundtype = findMirror(currentLibrary.types, match[1]);
+        String typeName = match[1];
+        InterfaceMirror foundtype = currentLibrary.types[typeName];
         if (foundtype == null) return;
+        String constructorName =
+            match[2] == null ? typeName : '$typeName.${match[2]}';
         final constructor =
-            findMirror(foundtype.constructors,
-                            match[2] == null ? '' : match[2]);
+            foundtype.constructors[constructorName];
         if (constructor == null) return;
         return makeLink(memberUrl(constructor));
       })();
       if (constructorLink != null) return constructorLink;
 
       // See if it's a member of another type
       final foreignMemberLink = (() {
         final match = new RegExp(r'([\w$]+)\.([\w$]+)').firstMatch(name);
         if (match == null) return;
-        InterfaceMirror foundtype = findMirror(currentLibrary.types, match[1]);
+        InterfaceMirror foundtype = currentLibrary.types[match[1]];
         if (foundtype == null) return;
-        MemberMirror foundMember = findMirror(foundtype.declaredMembers, match[2]);
+        MemberMirror foundMember = foundtype.declaredMembers[match[2]];
         if (foundMember == null) return;
         return makeLink(memberUrl(foundMember));
       })();
       if (foreignMemberLink != null) return foreignMemberLink;
 
-      InterfaceMirror foundType = findMirror(currentLibrary.types, name);
+      InterfaceMirror foundType = currentLibrary.types[name];
       if (foundType != null) {
         return makeLink(typeUrl(foundType));
       }
 
       // See if it's a top-level member in the current library.
-      MemberMirror foundMember = findMirror(currentLibrary.declaredMembers, name);
+      MemberMirror foundMember = currentLibrary.declaredMembers[name];
       if (foundMember != null) {
         return makeLink(memberUrl(foundMember));
       }
     }
 
     // TODO(rnystrom): Should also consider:
     // * Names imported by libraries this library imports.
     // * Type parameters of the enclosing type.
 
     return new md.Element.text('code', name);
@@ skipping 43 matching lines @@
 
 /**
  * Used to report an unexpected error in the DartDoc tool or the
  * underlying data
  */
 class InternalError {
   final String message;
   const InternalError(this.message);
   String toString() => "InternalError: '$message'";
 }