Rename InterfaceMirror to ClassMirror

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 209 matching lines @@
    * This list contains the libraries sorted in by the library name.
    */
   List<LibraryMirror> _sortedLibraries;
 
   CommentMap _comments;
 
   /** The library that we're currently generating docs for. */
   LibraryMirror _currentLibrary;
 
   /** The type that we're currently generating docs for. */
-  InterfaceMirror _currentType;
+  ClassMirror _currentType;
 
   /** The member that we're currently generating docs for. */
   MemberMirror _currentMember;
 
   /** The path to the file currently being written to, relative to [outdir]. */
   Path _filePath;
 
   /** The file currently being written to. */
   StringBuffer _file;
 
@@ skipping 338 matching lines @@
 
   void docLibraryNavigationJson(LibraryMirror library, List libraryList) {
     var libraryInfo = {};
     libraryInfo[NAME] = displayName(library);
     final List members = docMembersJson(library.declaredMembers);
     if (!members.isEmpty) {
       libraryInfo[MEMBERS] = members;
     }
 
     final types = [];
-    for (InterfaceMirror type in orderByName(library.types.values)) {
+    for (ClassMirror type in orderByName(library.types.values)) {
       if (!showPrivate && type.isPrivate) continue;
 
       var typeInfo = {};
       typeInfo[NAME] = type.displayName;
       if (type.isClass) {
         typeInfo[KIND] = CLASS;
       } else if (type.isInterface) {
         typeInfo[KIND] = INTERFACE;
       } else {
         assert(type.isTypedef);
@@ skipping 74 matching lines @@
         if (_currentLibrary == library) docLibraryNavigation(library);
       }
     }
 
     writeln('</div>');
   }
 
   /** Writes the navigation for the types contained by the given library. */
   void docLibraryNavigation(LibraryMirror library) {
     // Show the exception types separately.
-    final types = <InterfaceMirror>[];
-    final exceptions = <InterfaceMirror>[];
+    final types = <ClassMirror>[];
+    final exceptions = <ClassMirror>[];
 
-    for (InterfaceMirror type in orderByName(library.types.values)) {
+    for (ClassMirror type in orderByName(library.types.values)) {
       if (!showPrivate && type.isPrivate) continue;
 
       if (isException(type)) {
         exceptions.add(type);
       } else {
         types.add(type);
       }
     }
 
     if ((types.length == 0) && (exceptions.length == 0)) return;
 
     writeln('<ul class="icon">');
     types.forEach(docTypeNavigation);
     exceptions.forEach(docTypeNavigation);
     writeln('</ul>');
   }
 
   /** Writes a linked navigation list item for the given type. */
-  void docTypeNavigation(InterfaceMirror type) {
+  void docTypeNavigation(ClassMirror type) {
     var icon = 'interface';
     if (type.simpleName.endsWith('Exception')) {
       icon = 'exception';
     } else if (type.isClass) {
       icon = 'class';
     }
 
     write('<li>');
     if (_currentType == type) {
       write(
@@ skipping 21 matching lines @@
     // Look for a comment for the entire library.
     final comment = getLibraryComment(library);
     if (comment != null) {
       writeln('<div class="doc">${comment.html}</div>');
     }
 
     // Document the top-level members.
     docMembers(library);
 
     // Document the types.
-    final classes = <InterfaceMirror>[];
-    final interfaces = <InterfaceMirror>[];
+    final classes = <ClassMirror>[];
+    final interfaces = <ClassMirror>[];
     final typedefs = <TypedefMirror>[];
-    final exceptions = <InterfaceMirror>[];
+    final exceptions = <ClassMirror>[];
 
-    for (InterfaceMirror type in orderByName(library.types.values)) {
+    for (ClassMirror type in orderByName(library.types.values)) {
       if (!showPrivate && type.isPrivate) continue;
 
       if (isException(type)) {
         exceptions.add(type);
       } else if (type.isClass) {
         classes.add(type);
       } else if (type.isInterface){
         interfaces.add(type);
       } else if (type is TypedefMirror) {
         typedefs.add(type);
@@ skipping 29 matching lines @@
           <div class="type">
           <h4>
             ${a(typeUrl(type), "<strong>${typeName(type)}</strong>")}
           </h4>
           </div>
           ''');
     }
     writeln('</div>');
   }
 
-  void docType(InterfaceMirror type) {
+  void docType(ClassMirror type) {
     if (verbose) {
       print('- ${type.simpleName}');
     }
     _totalTypes++;
     _currentType = type;
 
     startFile(typeUrl(type));
 
     var kind = 'interface';
     if (type.isTypedef) {
@@ skipping 38 matching lines @@
   /** Override this to write additional content at the end of a type's page. */
   void writeTypeFooter() {
     // Do nothing.
   }
 
   /**
    * Writes an inline type span for the given type. This is a little box with
    * an icon and the type's name. It's similar to how types appear in the
    * navigation, but is suitable for inline (as opposed to in a `<ul>`) use.
    */
-  void typeSpan(InterfaceMirror type) {
+  void typeSpan(ClassMirror type) {
     var icon = 'interface';
     if (type.simpleName.endsWith('Exception')) {
       icon = 'exception';
     } else if (type.isClass) {
       icon = 'class';
     }
 
     write('<span class="type-box"><span class="icon-$icon"></span>');
     if (_currentType == type) {
       write('<strong>${typeName(type)}</strong>');
     } else {
       write(a(typeUrl(type), typeName(type)));
     }
     write('</span>');
   }
 
   /**
    * Document the other types that touch [Type] in the inheritance hierarchy:
    * subclasses, superclasses, subinterfaces, superinferfaces, and default
    * class.
    */
-  void docInheritance(InterfaceMirror type) {
+  void docInheritance(ClassMirror type) {
     // Don't show the inheritance details for Object. It doesn't have any base
     // class (obviously) and it has too many subclasses to be useful.
     if (type.isObject) return;
 
     // Writes an unordered list of references to types with an optional header.
     listTypes(types, header) {
       if (types == null) return;
 
       var publicTypes;
       if (showPrivate) {
@@ skipping 139 matching lines @@
             staticSetters[member.displayName] = member;
           } else {
             staticMethods.add(member);
           }
         } else if (member is FieldMirror) {
           staticGetters[member.displayName] = member;
         }
       }
     });
 
-    if (host is InterfaceMirror) {
+    if (host is ClassMirror) {
       var iterable = new HierarchyIterable(host, includeType: true);
-      for (InterfaceMirror type in iterable) {
+      for (ClassMirror type in iterable) {
         if (!host.isObject && !inheritFromObject && type.isObject) continue;
 
         type.declaredMembers.forEach((_, MemberMirror member) {
           if (member.isStatic) return;
           if (!showPrivate && member.isPrivate) return;
 
           bool inherit = true;
           if (type !== host) {
             if (member.isPrivate) {
               // Don't inherit private members.
@@ skipping 383 matching lines @@
    * Documents the source code contained within [location].
    */
   void docCode(Location location) {
     if (includeSource) {
       writeln('<pre class="source">');
       writeln(md.escapeHtml(unindentCode(location)));
       writeln('</pre>');
     }
   }
 
-  DocComment createDocComment(String text, [InterfaceMirror inheritedFrom]) =>
+  DocComment createDocComment(String text, [ClassMirror inheritedFrom]) =>
       new DocComment(text, inheritedFrom);
 
 
   /** Get the doc comment associated with the given library. */
   DocComment getLibraryComment(LibraryMirror library) {
     // Look for a comment for the entire library.
     final comment = _comments.findLibrary(library.location.source);
     if (comment == null) return null;
     return createDocComment(comment);
   }
 
   /** Get the doc comment associated with the given type. */
   DocComment getTypeComment(TypeMirror type) {
     String comment = _comments.find(type.location);
     if (comment == null) return null;
     return createDocComment(comment);
   }
 
   /**
    * Get the doc comment associated with the given member.
    *
    * If no comment was found on the member, the hierarchy is traversed to find
    * an inherited comment, favouring comments inherited from classes over
    * comments inherited from interfaces.
    */
   DocComment getMemberComment(MemberMirror member) {
     String comment = _comments.find(member.location);
-    InterfaceMirror inheritedFrom = null;
+    ClassMirror inheritedFrom = null;
     if (comment == null) {
-      if (member.surroundingDeclaration is InterfaceMirror) {
+      if (member.surroundingDeclaration is ClassMirror) {
         var iterable =
             new HierarchyIterable(member.surroundingDeclaration,
                                   includeType: false);
-        for (InterfaceMirror type in iterable) {
+        for (ClassMirror type in iterable) {
           var inheritedMember = type.declaredMembers[member.simpleName];
           if (inheritedMember is MemberMirror) {
             comment = _comments.find(inheritedMember.location);
             if (comment != null) {
               inheritedFrom = type;
               break;
             }
           }
         }
       }
@@ skipping 105 matching lines @@
       return;
     }
 
     if (type.isTypeVariable) {
       // If we're using a type parameter within the body of a generic class then
       // just link back up to the class.
       write(a(typeUrl(enclosingType), type.simpleName));
       return;
     }
 
-    assert(type is InterfaceMirror);
+    assert(type is ClassMirror);
 
     // Link to the type.
     if (shouldLinkToPublicApi(type.library)) {
       write('<a href="$API_LOCATION${typeUrl(type)}">${type.simpleName}</a>');
     } else if (shouldIncludeLibrary(type.library)) {
       write(a(typeUrl(type), type.simpleName));
     } else {
       write(type.simpleName);
     }
 
@@ skipping 10 matching lines @@
       for (final arg in typeArgs) {
         if (!first) write(', ');
         first = false;
         linkToType(enclosingType, arg);
       }
       write('&gt;');
     }
   }
 
   /** Creates a linked cross reference to [type]. */
-  typeReference(InterfaceMirror type) {
+  typeReference(ClassMirror type) {
     // TODO(rnystrom): Do we need to handle ParameterTypes here like
     // annotation() does?
     return a(typeUrl(type), typeName(type), css: 'crossref');
   }
 
   /** Generates a human-friendly string representation for a type. */
   typeName(TypeMirror type, {bool showBounds: false}) {
     if (type.isVoid) {
       return 'void';
     }
     if (type is TypeVariableMirror) {
       return type.simpleName;
     }
-    assert(type is InterfaceMirror);
+    assert(type is ClassMirror);
 
     // See if it's a generic type.
     if (type.isDeclaration) {
       final typeParams = [];
       for (final typeParam in type.declaration.typeVariables) {
         if (showBounds &&
             (typeParam.bound != null) &&
             !typeParam.bound.isObject) {
           final bound = typeName(typeParam.bound, showBounds: true);
           typeParams.add('${typeParam.simpleName} extends $bound');
@@ skipping 81 matching lines @@
 
     // 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;
         String typeName = match[1];
-        InterfaceMirror foundtype = currentLibrary.types[typeName];
+        ClassMirror foundtype = currentLibrary.types[typeName];
         if (foundtype == null) return;
         String constructorName =
             (match[2] == null) ? typeName : '$typeName.${match[2]}';
         final constructor =
             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 = currentLibrary.types[match[1]];
+        ClassMirror foundtype = currentLibrary.types[match[1]];
         if (foundtype == null) return;
         MemberMirror foundMember = foundtype.declaredMembers[match[2]];
         if (foundMember == null) return;
         return makeLink(memberUrl(foundMember));
       })();
       if (foreignMemberLink != null) return foreignMemberLink;
 
-      InterfaceMirror foundType = currentLibrary.types[name];
+      ClassMirror 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 = currentLibrary.declaredMembers[name];
       if (foundMember != null) {
         return makeLink(memberUrl(foundMember));
       }
     }
@@ skipping 56 matching lines @@
   const InternalError(this.message);
   String toString() => "InternalError: '$message'";
 }
 
 class DocComment {
   final String text;
 
   /**
    * Non-null if the comment is inherited from another declaration.
    */
-  final InterfaceMirror inheritedFrom;
+  final ClassMirror inheritedFrom;
 
   DocComment(this.text, [this.inheritedFrom = null]) {
     assert(text != null && !text.trim().isEmpty);
   }
 
   String get html => md.markdownToHtml(text);
 
   String toString() => text;
 }